@forge-dashboard/sdk-node 1.1.0 → 2.0.1

package/dist/generated/schema.d.ts

@@ -0,0 +1,3756 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export interface paths {
+    "/api/auth/registration-status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Whether self-registration is open
+         * @description Unauthenticated — a visitor deciding whether to show the login
+         *     page's own "Register a new passkey instead" button has no session
+         *     yet by definition. `open` is true only on a fresh instance with
+         *     zero registered users; once any account exists, self-registration
+         *     is closed and every registration after that requires a valid
+         *     `inviteToken` (see POST /api/auth/register/begin).
+         */
+        get: operations["getRegistrationStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/register/begin": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start a passkey registration ceremony
+         * @description The very first registration on a fresh instance (zero registered
+         *     users — see GET /api/auth/registration-status) needs no
+         *     `inviteToken` and bootstraps that account as admin. Every
+         *     registration after that requires a valid, unexpired, unconsumed
+         *     `inviteToken` issued by an admin (POST /api/admin/invites) for
+         *     exactly this `username` — the invite's own `displayName` is what's
+         *     actually used, not this request's.
+         */
+        post: operations["beginRegistration"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/register/finish": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Complete a passkey registration ceremony */
+        post: operations["finishRegistration"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/login/begin": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Start a passkey login ceremony */
+        post: operations["beginLogin"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/login/finish": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Complete a passkey login ceremony */
+        post: operations["finishLogin"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/logout": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** End the current session */
+        post: operations["logout"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/session": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Who, if anyone, the current session cookie belongs to */
+        get: operations["getSession"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/credentials": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the signed-in user's own passkeys
+         * @description Every passkey on the account (#355), oldest first — not just the
+         *     one used to establish the current session.
+         */
+        get: operations["listCredentials"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/credentials/begin": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start a ceremony to add another passkey to the signed-in account
+         * @description The authenticated counterpart to POST /api/auth/register/begin —
+         *     that one only ever works for a brand-new, credential-less
+         *     account; this is how an already-registered user adds a second
+         *     (or third...) passkey, e.g. a laptop and a security key (#355).
+         */
+        post: operations["beginAddCredential"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/credentials/finish": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Complete an add-credential ceremony */
+        post: operations["finishAddCredential"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/credentials/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Remove one of the signed-in user's own passkeys
+         * @description Refused on the account's last remaining passkey (#355) — this
+         *     app is WebAuthn-only with no password fallback, so deleting it
+         *     would lock the account out entirely.
+         */
+        delete: operations["deleteCredential"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/settings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The signed-in user's own forge configuration
+         * @description Tokens are never returned, before or after being saved — only
+         *     whether one is currently on file. There is no way to read a saved
+         *     token back out through this API.
+         */
+        get: operations["getSettings"];
+        /**
+         * Save the signed-in user's forge configuration
+         * @description Replaces every field except a blank token, which means "keep
+         *     whatever's already saved" rather than "clear it" — the only
+         *     sensible behavior for a field the browser is never shown the
+         *     current value of. Saving triggers that user's dashboard to start
+         *     refreshing from the new configuration.
+         */
+        put: operations["putSettings"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/settings/bot-pr-updates": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Whether bot-managed pull request branches can be updated
+         * @description A lightweight, side-effect-free read of one field —
+         *     allowBotPrUpdates — for the dashboard page to check on every
+         *     load. Deliberately not GET /api/settings itself: that handler
+         *     also provisions webhook credentials on first call
+         *     (EnsureWebhookCredentials), which the dashboard visiting on a
+         *     user's behalf shouldn't trigger for someone who's never opened
+         *     Settings at all.
+         */
+        get: operations["getBotPrUpdatesSetting"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/settings/theme": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The signed-in user's own saved theme preference
+         * @description A lightweight, side-effect-free read of one field — theme — for
+         *     every page to check on load (#352). The same "deliberately not
+         *     GET /api/settings itself" restraint GET /api/settings/bot-pr-updates
+         *     already uses, for the same reason: this loads on every page visit
+         *     and shouldn't provision webhook credentials as a side effect.
+         */
+        get: operations["getTheme"];
+        /**
+         * Save the signed-in user's own theme preference
+         * @description A dedicated, instant save (#352) — deliberately not routed
+         *     through the main PUT /api/settings, whose every other field is
+         *     a plain replace rather than a per-field merge: a request
+         *     carrying only theme through that handler would blank every
+         *     other saved setting. Picking a theme applies immediately, the
+         *     same "set once and forget" convention the ticket's own research
+         *     cites, rather than waiting on the rest of the settings form's
+         *     own Save button.
+         */
+        put: operations["setTheme"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/settings/filter-state": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The signed-in user's own saved dashboard/Insights filter state
+         * @description A lightweight read of one opaque blob (#353), the same
+         *     "deliberately not GET /api/settings itself" restraint
+         *     GET /api/settings/bot-pr-updates already uses, for the same
+         *     reason: this loads on every dashboard/Insights visit and
+         *     shouldn't provision webhook credentials as a side effect.
+         *     `{}` for a user who's never saved any filters yet, not a 404.
+         */
+        get: operations["getFilterState"];
+        /**
+         * Save the signed-in user's own dashboard/Insights filter state
+         * @description A dedicated, lightweight save separate from the main
+         *     PUT /api/settings — filters change on nearly every click, a
+         *     mismatch for that endpoint's "always a full form submit"
+         *     convention (#353). The body replaces the saved state entirely,
+         *     the same "always a full submit, just of a much smaller and
+         *     much more frequent thing" shape as the main settings PUT, not a
+         *     partial patch. Filters.js's own client-side code decides when
+         *     to call this: immediately for a discrete control, debounced
+         *     while the user is still typing in the free-text Title filter.
+         */
+        put: operations["setFilterState"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the signed-in user's own personal API tokens
+         * @description Metadata only, per APIToken's own description — a raw value never reappears once created.
+         */
+        get: operations["listAPITokens"];
+        put?: never;
+        /** Generate a new personal API token */
+        post: operations["createAPIToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Revoke a personal API token
+         * @description Stops the token authenticating immediately. Idempotent — deleting
+         *     an id that's already gone (or never belonged to the signed-in
+         *     user) still answers 204, the same as any other delete-by-id
+         *     endpoint here (compare DELETE /api/sharing/{username}), so a
+         *     double-click or a retried request isn't an error.
+         */
+        delete: operations["deleteAPIToken"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/webhooks/ensure": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create or fix up a webhook on one tracked repo, on the signed-in user's behalf
+         * @description Creates a webhook on the named repo, pointed at the signed-in
+         *     user's own webhook URL and secret, subscribed to the events
+         *     docs/webhooks.md's manual steps recommend. If one already exists
+         *     there (found the same way GET /api/dashboard's own `hasWebhook`
+         *     does — matching by URL path, not object identity) it's brought
+         *     back to active with the right events instead of creating a
+         *     duplicate.
+         *
+         *     One of a small number of endpoints in this API that write to a
+         *     forge rather than just reading from it — see also the
+         *     pull-requests tag.
+         */
+        post: operations["ensureWebhook"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/repos/ignore": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Hide one tracked repo's pull requests, issues, or both from the dashboard and Insights
+         * @description Reversible, not destructive (#363): the repo itself keeps
+         *     appearing in GET /api/dashboard's `repos` array with accurate
+         *     webhook-coverage status, and keeps being fetched and counted —
+         *     only the pullRequests and/or issues entries the request scopes
+         *     (#511) stop appearing there and on Insights. A repeat call
+         *     replaces the previously saved scope rather than merging with it
+         *     (ignoring PRs only, then issues only, ends with only issues
+         *     ignored) — idempotent for an identical repeat, not additive
+         *     across different scopes.
+         */
+        post: operations["ignoreRepo"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/repos/unignore": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Stop ignoring one tracked repo
+         * @description The reverse of POST /api/repos/ignore. Idempotent: un-ignoring a
+         *     repo that was never ignored is a no-op, not an error.
+         */
+        post: operations["unignoreRepo"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/repos/auto-update-branch/enable": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Turn on automatic branch updates for one tracked repo
+         * @description Any of this repo's pull requests the background refresh finds
+         *     behind its base branch gets updated automatically from then on
+         *     (#365), the same as clicking "Update branch" would — suppressed
+         *     for a bot-managed pull request unless bot-PR updates are
+         *     separately allowed. Idempotent: enabling an already-enabled repo
+         *     is a no-op, not an error.
+         */
+        post: operations["enableAutoUpdateBranch"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/repos/auto-update-branch/disable": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Turn off automatic branch updates for one tracked repo
+         * @description The reverse of POST /api/repos/auto-update-branch/enable.
+         *     Idempotent: disabling a repo that was never enabled is a no-op,
+         *     not an error.
+         */
+        post: operations["disableAutoUpdateBranch"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/pull-requests/merge": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Merge one pull request, on the signed-in user's behalf
+         * @description Merges the named pull request using its repo's own configured
+         *     default merge method — GitHub is asked to pick its own repo
+         *     default; Forgejo's API has no such default built in, so this
+         *     looks up the repo's configured default merge style first and
+         *     passes that explicitly. Neither takes a method override here;
+         *     picking one is out of scope for this endpoint.
+         */
+        post: operations["mergePullRequest"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/pull-requests/close": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Close one pull request without merging it, on the signed-in user's behalf
+         * @description Closes the named pull request — for one that turns out not to
+         *     need merging at all (a duplicate, or one whose content already
+         *     landed another way), not a substitute for Merge.
+         */
+        post: operations["closePullRequest"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/pull-requests/update-branch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Bring one pull request's branch up to date with its base, on the signed-in user's behalf
+         * @description Merges the named pull request's base branch into its own head
+         *     branch. GitHub can schedule this as a background job rather than
+         *     finishing it inline — a 202 here means exactly that, not a
+         *     failure; a follow-up refresh a moment later reflects the result.
+         *     Forgejo's equivalent is always synchronous, so it only ever
+         *     answers 204.
+         */
+        post: operations["updatePullRequestBranch"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/pull-requests/dependabot-action": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Post one of Dependabot's own documented PR-comment commands on a pull request, on the signed-in user's behalf
+         * @description Posts exactly `@dependabot rebase` or `@dependabot recreate` as a
+         *     comment on the named pull request — Dependabot's own documented
+         *     comment-command interface, not a generic "post any comment"
+         *     endpoint; `action` is validated server-side to one of the two
+         *     values below and nothing else is ever sent. GitHub only —
+         *     Dependabot doesn't run on Forgejo.
+         */
+        post: operations["postPullRequestDependabotAction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/pull-requests/renovate-rebase": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Trigger Renovate's own rebase/retry on a pull request, on the signed-in user's behalf
+         * @description Adds the signed-in user's own configured Renovate rebase label
+         *     (Settings' "Renovate rebase label" field, defaulting to
+         *     Renovate's own `rebase` if left blank) to the named pull
+         *     request — Renovate's own documented rebase/retry trigger, which
+         *     is a label rather than a comment command. Works on both GitHub
+         *     and Forgejo, unlike the Dependabot actions, since Renovate runs
+         *     on both.
+         */
+        post: operations["postPullRequestRenovateRebase"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/pull-requests/checks": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List every job/check run against a pull request's head commit, on demand
+         * @description Fetched live on every call, never as part of GET /api/dashboard's
+         *     own snapshot — this is detail a pull request's row doesn't show
+         *     until a caller actually asks for it, and adding it to the eager
+         *     refresh loop would multiply that refresh's cost by every open
+         *     pull request for data most of them are never opened for.
+         *
+         *     Falls back to the legacy combined commit-status API's own
+         *     per-check entries when the forge reports no Actions runs at all
+         *     for that commit (Actions disabled, or an instance too old to
+         *     expose them) — never an error for that case specifically, since
+         *     it's a normal, expected shape for an older or CI-less repo.
+         */
+        get: operations["getPullRequestChecks"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/users": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List every registered user
+         * @description Never includes a passkey or a forge credential — a username,
+         *     display name, admin flag and registration timestamp per user.
+         */
+        get: operations["listUsers"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/users/{username}/revoke": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Revoke a user's passkeys and sessions
+         * @description Deletes every session and every registered passkey for this user —
+         *     they're signed out everywhere immediately, and have to register a
+         *     new passkey from scratch to get back in. Their saved forge
+         *     credentials are untouched; use the delete endpoint to remove the
+         *     account itself.
+         */
+        post: operations["revokeUser"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/users/{username}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Remove a user outright
+         * @description Deletes the account, every session, every registered passkey, and
+         *     every saved forge credential — irreversible. Their username
+         *     becomes available for a fresh registration.
+         */
+        delete: operations["deleteUser"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/invites": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List outstanding registration invites
+         * @description Every invite that's neither consumed nor expired — never the raw
+         *     token, only its own stable id (see AdminInvite).
+         */
+        get: operations["listInvites"];
+        put?: never;
+        /**
+         * Generate a new single-use registration invite
+         * @description The admin picks the username and display name up front — the
+         *     invitee only completes the WebAuthn ceremony at the link this
+         *     returns (`/login?invite=<token>`, built client-side). Valid for
+         *     one hour, fixed.
+         */
+        post: operations["createInvite"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/invites/{token}/revoke": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Revoke an outstanding invite
+         * @description Stops the invite's token from ever completing a registration.
+         *     `token` here is an invite's own `id` (from AdminInvite's own
+         *     listing), never the raw secret an invitee would use to register —
+         *     that's AdminInviteCreateResponse's own `token` field, and it's
+         *     never listed again after creation.
+         */
+        post: operations["revokeInvite"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/healthz": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Liveness
+         * @description Answers 200 once the server has started. Doesn't reflect whether
+         *     either forge is reachable — see forges[].reachable on the dashboard
+         *     response for that.
+         */
+        get: operations["health"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/version": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The running server's own version
+         * @description The tag goreleaser stamped the running binary with ("dev" for a
+         *     build outside the release pipeline). Public and unauthenticated —
+         *     every page, including the pre-login screen, links to the matching
+         *     GitHub release from its footer so a person can tell what's
+         *     actually deployed without shelling into the box.
+         */
+        get: operations["getVersion"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/dashboard": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The aggregated view
+         * @description Returns the most recently fetched snapshot. The backend refreshes
+         *     this on its own schedule in the background; this endpoint never
+         *     blocks on a live call to either forge, so it answers instantly even
+         *     when a forge is slow or unreachable.
+         *
+         *     Omitting `owner` returns the signed-in user's own dashboard. Passing
+         *     it returns that user's dashboard instead — allowed only when they've
+         *     shared it with the caller (or the caller is viewing their own
+         *     username), and refused with a 403 otherwise.
+         */
+        get: operations["getDashboard"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/dashboard/stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Server-Sent Events stream of the signed-in user's own dashboard
+         * @description Pushes a fresh snapshot every time this user's background
+         *     refresh produces one — most notably right after a verified
+         *     webhook delivery (see the webhooks tag) triggers an immediate
+         *     one, which is what turns that into a live update instead of
+         *     something only the next scheduled refresh picks up.
+         *
+         *     Doesn't support `owner` the way GET /api/dashboard does — only
+         *     ever the signed-in user's own dashboard, never a shared one.
+         *     The frontend's own 30-second poll against GET /api/dashboard
+         *     keeps running unconditionally, connected or not — a browser or
+         *     proxy that can't hold an SSE connection open just never
+         *     benefits from this, rather than the dashboard going stale
+         *     silently.
+         */
+        get: operations["streamDashboard"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/dashboard/refresh": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Trigger an immediate refresh of the signed-in user's own dashboard
+         * @description Blocks until an immediate, out-of-band refresh of the signed-in
+         *     user's own dashboard completes, then returns the resulting
+         *     snapshot — for retrying right away after a forge was only
+         *     briefly unreachable, instead of waiting for the next scheduled
+         *     background refresh.
+         *
+         *     Doesn't support `owner` the way GET /api/dashboard does — only
+         *     ever the signed-in user's own dashboard, never a shared one, so
+         *     a user with shared access to someone else's dashboard can never
+         *     spend that owner's own forge rate-limit budget on their own
+         *     schedule.
+         */
+        post: operations["refreshDashboard"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sharing": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The signed-in user's sharing relationships
+         * @description Both directions at once: who the signed-in user has shared their
+         *     own dashboard with, and whose dashboards have been shared with
+         *     them.
+         */
+        get: operations["getSharing"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sharing/{username}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Share the signed-in user's dashboard with username
+         * @description Idempotent — sharing with a username already on the list changes
+         *     nothing. username needs no tokens of their own configured to view
+         *     the shared dashboard; they see the owner's aggregated data exactly
+         *     as the owner sees it.
+         */
+        put: operations["shareWith"];
+        post?: never;
+        /**
+         * Stop sharing the signed-in user's dashboard with username
+         * @description Idempotent — removing a username that was never shared with changes nothing.
+         */
+        delete: operations["unshareWith"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/webhooks/github/{webhookToken}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Receive a GitHub repository webhook delivery
+         * @description Triggers an immediate refresh for the user webhookToken identifies,
+         *     once the request's `X-Hub-Signature-256` header is verified against
+         *     that user's webhook secret. Every delivery GitHub can send for a
+         *     repository webhook (a new pull request, a closed issue, a status or
+         *     check-run update, even the `ping` event GitHub sends when the
+         *     webhook is first created) means the same thing here — something
+         *     changed, refresh — so nothing about the payload itself is parsed.
+         */
+        post: operations["receiveGitHubWebhook"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/webhooks/forgejo/{webhookToken}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Receive a Forgejo repository webhook delivery
+         * @description Triggers an immediate refresh for the user webhookToken identifies,
+         *     once the request's signature header is verified against that
+         *     user's webhook secret — `X-Forgejo-Signature` on a webhook set up
+         *     with the "Forgejo" type, `X-Gitea-Signature` on one set up with the
+         *     legacy "Gitea" type; both carry the same raw hex HMAC-SHA256. Every
+         *     delivery means the same thing here — something changed, refresh —
+         *     so nothing about the payload itself is parsed.
+         */
+        post: operations["receiveForgejoWebhook"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        Health: {
+            /** @constant */
+            status: "ok";
+        };
+        Version: {
+            /**
+             * @description The release tag this binary was built from, with no leading
+             *     "v" — or "dev" for a build outside the release pipeline.
+             * @example 0.12.1
+             * @example dev
+             */
+            version: string;
+        };
+        Error: {
+            error: string;
+        };
+        RegisterBeginRequest: {
+            /** @example ryan */
+            username: string;
+            /**
+             * @description Ignored once an invite is required (any account already
+             *     exists) — the invite's own displayName (set by the admin who
+             *     issued it) is what's actually used. Only the very first,
+             *     bootstrap registration on a fresh instance takes this value.
+             * @example Ryan
+             */
+            displayName: string;
+            /**
+             * @description Required once any account already exists (see GET
+             *     /api/auth/registration-status) — a single-use token from POST
+             *     /api/admin/invites, issued for exactly this username. Omitted
+             *     or ignored for the very first, bootstrap registration.
+             */
+            inviteToken?: string;
+        };
+        RegistrationStatus: {
+            /** @description True only when the instance has zero registered users. */
+            open: boolean;
+        };
+        LoginBeginRequest: {
+            /** @example ryan */
+            username: string;
+        };
+        /**
+         * @description The WebAuthn specification's own JSON shape for
+         *     `PublicKeyCredentialCreationOptions`/`PublicKeyCredentialRequestOptions`
+         *     (the begin responses) and `PublicKeyCredential`
+         *     (the finish request bodies) — passed through to and from the
+         *     browser's own `navigator.credentials` API untouched, so this
+         *     contract intentionally doesn't re-model WebAuthn's own schema.
+         */
+        WebAuthnCeremonyOptions: {
+            [key: string]: unknown;
+        };
+        /**
+         * @description The dashboard/Insights filter bar's own saved shape (#353) —
+         *     whatever `filters.js`'s `loadState`/`saveState` already produce
+         *     client-side (shared forge/repo/label/author/title/created/
+         *     updated/groupBy, plus the two board-owned extras with no
+         *     equivalent on the other entity type). This server stores and
+         *     returns it verbatim, byte for byte, and never parses or
+         *     validates its shape — the same "opaque blob, not this layer's
+         *     concern" treatment WebAuthnCeremonyOptions above gets, so a
+         *     client-side shape change here never needs a matching spec change.
+         */
+        FilterState: {
+            [key: string]: unknown;
+        };
+        SessionUser: {
+            username: string;
+            displayName: string;
+            isAdmin: boolean;
+        };
+        AdminUser: {
+            username: string;
+            displayName: string;
+            isAdmin: boolean;
+            /** Format: date-time */
+            createdAt: string;
+        };
+        /**
+         * @description An outstanding (unconsumed, unexpired) invite's own metadata —
+         *     never the raw token, which only AdminInviteCreateResponse ever
+         *     carries, once, at creation time.
+         */
+        AdminInvite: {
+            /**
+             * @description The invite's own stable identifier — pass this back to POST
+             *     /api/admin/invites/{token}/revoke, not the raw token an
+             *     invitee registers with.
+             */
+            id: string;
+            username: string;
+            displayName: string;
+            /** Format: date-time */
+            expiresAt: string;
+        };
+        AdminInviteCreateRequest: {
+            /** @example alex */
+            username: string;
+            /** @example Alex */
+            displayName: string;
+        };
+        /**
+         * @description The one and only response that ever carries the raw invite token
+         *     — shown to the admin once, at creation time, for them to copy
+         *     into a `/login?invite=<token>` link and hand to the invitee out
+         *     of band. Only its hash is stored, so it can't be recovered from
+         *     here again.
+         */
+        AdminInviteCreateResponse: {
+            token: string;
+            username: string;
+            displayName: string;
+            /** Format: date-time */
+            expiresAt: string;
+        };
+        SharedUser: {
+            username: string;
+            displayName: string;
+        };
+        SharingResponse: {
+            /** @description Users the signed-in user has shared their own dashboard with. */
+            sharedWith: components["schemas"]["SharedUser"][];
+            /** @description Users who have shared their dashboard with the signed-in user. */
+            sharedWithMe: components["schemas"]["SharedUser"][];
+        };
+        /**
+         * @description The signed-in user's own GitHub/Forgejo configuration. Never
+         *     includes a forge token's value — only whether one is currently
+         *     saved, so the UI can show a "Configured" badge without the secret
+         *     ever reaching the browser. webhookToken/webhookSecret are the
+         *     exception: they're ours to hand back in the clear, since the user
+         *     has to paste them into the forge's own webhook setup.
+         */
+        SettingsResponse: {
+            /** @description Used as a token-free public-repos fallback when no GitHub token is set. */
+            githubUsername: string;
+            /** @description Whether a GitHub token is currently saved. */
+            githubTokenSet: boolean;
+            forgejoUrl: string;
+            /** @description Used as a token-free public-repos fallback when no Forgejo token is set. */
+            forgejoUsername: string;
+            /** @description Whether a Forgejo token is currently saved. */
+            forgejoTokenSet: boolean;
+            /**
+             * @description Identifies this user in a webhook URL
+             *     (`/api/webhooks/{provider}/{webhookToken}`). Generated on
+             *     first visit to Settings and stable after that.
+             */
+            webhookToken: string;
+            /**
+             * @description Pasted into the forge's own webhook "Secret" field, used to
+             *     verify the signature header on incoming webhook deliveries
+             *     (`X-Hub-Signature-256` on GitHub, `X-Forgejo-Signature` on
+             *     Forgejo). Never appears in the webhook URL itself.
+             */
+            webhookSecret: string;
+            /**
+             * @description Overrides the default restraint the Update branch/Dependabot/
+             *     Renovate action buttons apply to a pull request opened by
+             *     release-please, Dependabot, or Renovate — those tools already
+             *     keep their own PRs current on their own schedule. False (the
+             *     default) leaves bot-managed PRs alone; true treats them the
+             *     same as any other PR.
+             */
+            allowBotPrUpdates: boolean;
+            /**
+             * @description The label Renovate's own rebase/retry trigger listens for on
+             *     a repo (Renovate's own `rebaseLabel` config option — genuinely
+             *     per-repo configurable, so this is a user-set override rather
+             *     than a hardcoded constant). Empty means Renovate's own
+             *     documented default, `rebase`.
+             */
+            renovateRebaseLabel: string;
+            /**
+             * @description The signed-in user's own theme preference (#352). Empty
+             *     means "system" — follow the browser's prefers-color-scheme
+             *     rather than a saved choice. Set only from Settings; every
+             *     other page reads it via the lightweight
+             *     GET /api/settings/theme instead of this endpoint.
+             * @enum {string}
+             */
+            theme: "" | "light" | "dark";
+        };
+        /**
+         * @description Replaces the signed-in user's saved GitHub/Forgejo configuration.
+         *     A blank `githubToken` or `forgejoToken` keeps whatever token is
+         *     already saved for that forge rather than clearing it — this is
+         *     the only way to update the username fields without having to
+         *     resubmit a token you don't want to re-paste. Theme isn't
+         *     settable here at all — see PUT /api/settings/theme.
+         */
+        SettingsRequest: {
+            githubToken?: string;
+            githubUsername?: string;
+            forgejoUrl?: string;
+            forgejoToken?: string;
+            forgejoUsername?: string;
+            allowBotPrUpdates?: boolean;
+            renovateRebaseLabel?: string;
+        };
+        /** @description See GET /api/settings/bot-pr-updates's own description. */
+        BotPrUpdatesResponse: {
+            allowBotPrUpdates: boolean;
+        };
+        /** @description See GET /api/settings/theme's own description. */
+        ThemeResponse: {
+            /** @enum {string} */
+            theme: "" | "light" | "dark";
+        };
+        /** @description See PUT /api/settings/theme's own description. */
+        ThemeRequest: {
+            /** @enum {string} */
+            theme: "" | "light" | "dark";
+        };
+        /**
+         * @description A registered passkey's own metadata (#355) — never the
+         *     credential itself, which never leaves the authenticator that
+         *     created it; WebAuthn's whole design is that the server only ever
+         *     sees a public key and signed assertions, not a secret to lose.
+         */
+        Credential: {
+            /** @description This passkey's own credential ID (base64url), distinct from the account's user ID. */
+            id: string;
+            /** @description The name given at registration time, so a list of several is tellable apart. */
+            label: string;
+            /** Format: date-time */
+            createdAt: string;
+        };
+        /**
+         * @description A personal API token's own metadata — never the token value
+         *     itself, which only ever appears once, in
+         *     APITokenCreateResponse's own response body at creation time.
+         */
+        APIToken: {
+            id: string;
+            /** @description The name given at creation time, so a list of several is tellable apart. */
+            label: string;
+            /** Format: date-time */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description When this token stops authenticating requests (#356) —
+             *     always set, mandatory at creation, no "never expires"
+             *     option. A token whose expiration has passed is rejected the
+             *     same way an invalid one is.
+             */
+            expiresAt: string;
+            /**
+             * Format: date-time
+             * @description Omitted if this token has never authenticated a request yet.
+             */
+            lastUsedAt?: string;
+        };
+        APITokenCreateRequest: {
+            label: string;
+            /**
+             * Format: date-time
+             * @description Must be in the future and no more than 366 days out (#356,
+             *     matching GitHub's own fine-grained-token maximum) — the
+             *     Settings UI offers 7/30/60/90-day presets (30 pre-selected)
+             *     or a custom date within that same cap, never an option for
+             *     no expiration at all.
+             */
+            expiresAt: string;
+        };
+        /**
+         * @description The one and only response that ever carries the raw token value
+         *     — shown to the user once, at creation time; only its hash is
+         *     stored, so it can't be recovered from here again. Losing it
+         *     means generating a new one.
+         */
+        APITokenCreateResponse: {
+            id: string;
+            label: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            expiresAt: string;
+            /** @description The raw Bearer credential: `Authorization: Bearer <token>`. */
+            token: string;
+        };
+        /** @description Which repo to create or fix up a webhook on. */
+        WebhookEnsureRequest: {
+            forge: components["schemas"]["Forge"];
+            /** @description "owner/repo", matching a Repo.fullName from GET /api/dashboard. */
+            fullName: string;
+        };
+        /**
+         * @description Which repo to ignore, and in which scope(s) (#511). At least one
+         *     of prs/issues must be true — a request with both false is
+         *     rejected with 400 rather than silently doing nothing; use POST
+         *     /api/repos/unignore to clear both at once instead.
+         */
+        RepoIgnoreRequest: {
+            forge: components["schemas"]["Forge"];
+            /** @description "owner/repo", matching a Repo.fullName from GET /api/dashboard. */
+            fullName: string;
+            /** @description Whether to ignore this repo's pull requests. */
+            prs: boolean;
+            /** @description Whether to ignore this repo's issues. */
+            issues: boolean;
+        };
+        /** @description Which pull request to act on. */
+        PullRequestActionRequest: {
+            forge: components["schemas"]["Forge"];
+            /** @description "owner/repo", matching a Repo.fullName from GET /api/dashboard. */
+            fullName: string;
+            /** @description Matching a PullRequest.number from GET /api/dashboard. */
+            number: number;
+        };
+        /** @description Which pull request to act on, and which of Dependabot's own comment commands to send. */
+        PullRequestDependabotActionRequest: {
+            forge: components["schemas"]["Forge"];
+            /** @description "owner/repo", matching a Repo.fullName from GET /api/dashboard. */
+            fullName: string;
+            /** @description Matching a PullRequest.number from GET /api/dashboard. */
+            number: number;
+            /**
+             * @description Which Dependabot comment command to post — "@dependabot rebase" or "@dependabot recreate".
+             * @enum {string}
+             */
+            action: "rebase" | "recreate";
+        };
+        /** @enum {string} */
+        Forge: "github" | "forgejo";
+        /**
+         * @description The combined result across every check reported against the pull
+         *     request's head commit. "none" means neither forge reported any
+         *     check at all, not that one failed.
+         * @enum {string}
+         */
+        CIStatus: "success" | "failure" | "pending" | "none";
+        /**
+         * @description One job/check's own status — the per-job detail CIStatus
+         *     deliberately doesn't carry, since CIStatus is the combined result
+         *     across every one of them.
+         * @enum {string}
+         */
+        CheckState: "queued" | "running" | "success" | "failure" | "cancelled" | "skipped" | "timed_out";
+        /** @description One job/check run against a pull request's head commit. */
+        Check: {
+            name: string;
+            state: components["schemas"]["CheckState"];
+            /** @description That job's own page on the forge that ran it — never the pull request's own page. */
+            url: string;
+        };
+        PullRequestChecksResponse: {
+            checks: components["schemas"]["Check"][];
+        };
+        /**
+         * @description A pull request's mergeable/blocked state, as coarse as every forge
+         *     this service talks to can agree on. "blocked" covers anything
+         *     stopping a merge that isn't confirmed to be a real conflict —
+         *     including Forgejo's own mergeable flag reporting false, since its
+         *     server computes that asynchronously and can report it stale.
+         *     "unknown" covers both a forge that hasn't determined this yet and
+         *     this service being unable to determine it.
+         * @enum {string}
+         */
+        MergeStatus: "mergeable" | "conflicting" | "blocked" | "unknown";
+        Label: {
+            /** @example kind/bug */
+            name: string;
+            /**
+             * @description The label's colour as a hex string with no leading "#",
+             *     exactly as the forge reports it.
+             * @example d73a4a
+             */
+            color: string;
+        };
+        /**
+         * @description Why a forge is unreachable, or why a write to it was rejected, as
+         *     coarse as every forge this service talks to can agree on.
+         *     "unauthorized" covers both a bad token and a forbidden request;
+         *     "not_found" usually means a wrong instance URL. "conflict" is only
+         *     ever returned from a pull-request write — the forge reports the PR
+         *     itself isn't currently mergeable. "unknown" covers a signal this
+         *     service doesn't recognize, rather than a guessed-at specific cause.
+         * @enum {string}
+         */
+        ForgeErrorKind: "unreachable" | "unauthorized" | "not_found" | "rate_limited" | "conflict" | "unknown";
+        ForgeHealth: {
+            forge: components["schemas"]["Forge"];
+            /** @description Whether the last refresh attempt against this forge succeeded. */
+            reachable: boolean;
+            /** @description A human-readable explanation of the last failure, if reachable is false. Mapped from errorKind, not the raw underlying error text. Omitted when reachable. */
+            error?: string;
+            errorKind?: components["schemas"]["ForgeErrorKind"];
+            /** @description Repositories with write access this forge reported. */
+            repoCount: number;
+            /** @description GitHub's GraphQL budget (#361) — a completely separate 5000/hour allowance from rateLimitREST, populated from the rateLimit block GitHub embeds in every GraphQL response. Never set for a forge with no GraphQL API (Forgejo). */
+            rateLimitGraphQL?: components["schemas"]["RateLimit"];
+            /** @description The forge's REST budget, from real X-RateLimit-* response headers. For GitHub, this is checkWebhooks and every write action (merge, update branch, comment, label) — a different 5000/hour allowance from rateLimitGraphQL, not a duplicate of it. Omitted on a poll that made no REST call at all (no webhook path configured). For Forgejo, or any forge reached through GenericSource, this is the only budget there is to report — GenericSource makes exclusively REST-style calls. */
+            rateLimitREST?: components["schemas"]["RateLimit"];
+        };
+        /** @description One of a forge API's own request budgets for the credential the last refresh used — see ForgeHealth.rateLimitGraphQL/rateLimitREST for which budget this is and when each is (or isn't) reported. */
+        RateLimit: {
+            /** @description Requests allowed per window. */
+            limit: number;
+            /** @description Requests left in the current window. */
+            remaining: number;
+            /**
+             * Format: date-time
+             * @description When the window resets and remaining goes back to limit.
+             */
+            resetsAt: string;
+            /** @description The point price the most recent call was actually charged (#440) — GraphQL-specific, since a REST request has no separate cost concept beyond the flat one-request-one-point REST's own budget already counts. Omitted for a REST-sourced RateLimit. */
+            cost?: number;
+        };
+        PullRequest: {
+            forge: components["schemas"]["Forge"];
+            /**
+             * @description Owner-qualified repository name.
+             * @example alrayyes/hush-hush
+             */
+            repo: string;
+            number: number;
+            title: string;
+            /**
+             * Format: uri
+             * @description The real pull request URL on its own forge.
+             */
+            url: string;
+            author: string;
+            draft: boolean;
+            labels: components["schemas"]["Label"][];
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+            ci: components["schemas"]["CIStatus"];
+            mergeStatus: components["schemas"]["MergeStatus"];
+            /**
+             * @description Whether this pull request's base branch has moved since its
+             *     merge-base was computed. Deliberately its own field rather
+             *     than a mergeStatus value: on Forgejo a pull request can be
+             *     both mergeable and behind at once (its mergeable flag doesn't
+             *     get recomputed just because the base moved), so folding this
+             *     into mergeStatus would force picking one and losing the
+             *     other.
+             */
+            behind: boolean;
+            /**
+             * @description Whether auto-merge is currently scheduled on this pull request.
+             *     Omitted when the owning forge has no way to report this at all
+             *     (Forgejo, today) — never false in that case, since this service
+             *     genuinely doesn't know.
+             */
+            autoMergeEnabled?: boolean;
+        };
+        Issue: {
+            forge: components["schemas"]["Forge"];
+            /** @example alrayyes/hush-hush */
+            repo: string;
+            number: number;
+            title: string;
+            /**
+             * Format: uri
+             * @description The real issue URL on its own forge.
+             */
+            url: string;
+            author: string;
+            labels: components["schemas"]["Label"][];
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        Dashboard: {
+            /**
+             * Format: date-time
+             * @description When this snapshot was refreshed, not when it was requested.
+             */
+            generatedAt: string;
+            forges: components["schemas"]["ForgeHealth"][];
+            pullRequests: components["schemas"]["PullRequest"][];
+            issues: components["schemas"]["Issue"][];
+            repos: components["schemas"]["RepoStatus"][];
+        };
+        /**
+         * @description One tracked repository, whether or not it currently has anything
+         *     open — repoCount alone can't name it, and it wouldn't otherwise
+         *     appear anywhere pullRequests/issues don't already mention it.
+         */
+        RepoStatus: {
+            forge: components["schemas"]["Forge"];
+            /** @example alrayyes/forge-dashboard */
+            fullName: string;
+            /**
+             * Format: uri
+             * @description The repo's own page on its forge, for linking out.
+             * @example https://github.com/alrayyes/forge-dashboard
+             */
+            url: string;
+            /**
+             * @description Whether the signed-in user has ignored this repo in either
+             *     scope below (#363, #511) — true whenever ignoredPRs or
+             *     ignoredIssues is true. The repo itself still appears here
+             *     with accurate hasWebhook/canManageWebhooks regardless.
+             */
+            ignored: boolean;
+            /**
+             * @description Whether the signed-in user has ignored this repo's pull
+             *     requests specifically (#511) — its pullRequests entries are
+             *     excluded from this same response and from Insights.
+             */
+            ignoredPRs: boolean;
+            /**
+             * @description Whether the signed-in user has ignored this repo's issues
+             *     specifically (#511) — its issues entries are excluded from
+             *     this same response and from Insights.
+             */
+            ignoredIssues: boolean;
+            /**
+             * @description Whether this app has ever recorded a signature-verified
+             *     webhook delivery for this repo. Passive: it reflects a real
+             *     delivery having arrived, not whether a webhook object exists
+             *     on the forge — a correctly configured webhook that just
+             *     hasn't fired yet still reads false here, the same as a
+             *     misconfigured one would.
+             */
+            hasWebhook: boolean;
+            /**
+             * @description Whether the signed-in user's own permission on this repo is
+             *     enough to list/create its webhooks — GitHub requires admin
+             *     specifically (write/maintain can push but still 404 on the
+             *     hooks endpoint, by GitHub's own design); Forgejo's equivalent
+             *     is its own admin permission flag. Always false for a repo
+             *     reached through an unauthenticated, username-only listing.
+             *     A point-in-time snapshot: a permission change since the last
+             *     refresh can still make a following ensure-webhook call fail
+             *     despite this having said true.
+             */
+            canManageWebhooks: boolean;
+            /**
+             * @description Whether the signed-in user has turned on automatic branch
+             *     updates for this repo (#365) — any of its pull requests the
+             *     background refresh finds behind its base branch gets updated
+             *     the same way a manual "Update branch" click would, without
+             *     one. Suppressed for a bot-managed pull request (release-please,
+             *     Dependabot, Renovate) unless bot-PR updates are separately
+             *     allowed (POST /api/settings/bot-pr-updates), the same
+             *     restraint the manual button already applies.
+             */
+            autoUpdateBranch: boolean;
+        };
+    };
+    responses: never;
+    parameters: {
+        PathUsername: string;
+        PathWebhookToken: string;
+        PathTokenID: string;
+    };
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    getRegistrationStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The current registration status. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RegistrationStatus"];
+                };
+            };
+        };
+    };
+    beginRegistration: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RegisterBeginRequest"];
+            };
+        };
+        responses: {
+            /**
+             * @description WebAuthn credential creation options, passed straight to the
+             *     browser's `navigator.credentials.create()`.
+             */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebAuthnCeremonyOptions"];
+                };
+            };
+            /**
+             * @description Self-registration is closed (an account already exists) and
+             *     no valid, unexpired, unconsumed invite for this username was
+             *     presented.
+             */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description That username is already registered. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    finishRegistration: {
+        parameters: {
+            query: {
+                username: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * @description The raw response from `navigator.credentials.create()`, exactly as
+         *     the browser produced it — forwarded to the server untouched.
+         */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebAuthnCeremonyOptions"];
+            };
+        };
+        responses: {
+            /** @description Registration succeeded; a session cookie is now set. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionUser"];
+                };
+            };
+            /** @description The ceremony failed verification, or had already expired. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    beginLogin: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["LoginBeginRequest"];
+            };
+        };
+        responses: {
+            /**
+             * @description WebAuthn credential request options, passed straight to the
+             *     browser's `navigator.credentials.get()`.
+             */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebAuthnCeremonyOptions"];
+                };
+            };
+            /** @description No account is registered under that username. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    finishLogin: {
+        parameters: {
+            query: {
+                username: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * @description The raw response from `navigator.credentials.get()`, exactly as
+         *     the browser produced it — forwarded to the server untouched.
+         */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebAuthnCeremonyOptions"];
+            };
+        };
+        responses: {
+            /** @description Login succeeded; a session cookie is now set. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionUser"];
+                };
+            };
+            /** @description The ceremony failed verification, or had already expired. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    logout: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Logged out; the session cookie is now cleared. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    getSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The current session's user. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionUser"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    listCredentials: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Every registered passkey. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Credential"][];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    beginAddCredential: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /**
+             * @description WebAuthn credential creation options, passed straight to the
+             *     browser's `navigator.credentials.create()`. `excludeCredentials`
+             *     already lists every passkey the account has, so re-registering
+             *     the same authenticator is refused by the browser itself.
+             */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebAuthnCeremonyOptions"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    finishAddCredential: {
+        parameters: {
+            query: {
+                /**
+                 * @description A name the user recognizes, e.g. "MacBook" or "YubiKey"
+                 *     (#355) — prompted for at registration time, never derived
+                 *     from the authenticator itself.
+                 */
+                label: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * @description The raw response from `navigator.credentials.create()`, exactly as
+         *     the browser produced it — forwarded to the server untouched.
+         */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebAuthnCeremonyOptions"];
+            };
+        };
+        responses: {
+            /** @description The new passkey is now registered. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Credential"];
+                };
+            };
+            /** @description label was blank, or the ceremony failed verification, or had already expired. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    deleteCredential: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Removed. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description This is the account's last remaining passkey. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    getSettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The current settings. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SettingsResponse"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    putSettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SettingsRequest"];
+            };
+        };
+        responses: {
+            /** @description Saved. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SettingsResponse"];
+                };
+            };
+            /**
+             * @description The request body wasn't valid JSON, or a Forgejo token/username
+             *     was set with no Forgejo URL — a combination the dashboard can't
+             *     use, since the URL is what a token or username connects to.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    getBotPrUpdatesSetting: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The current value. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BotPrUpdatesResponse"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    getTheme: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The current value. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ThemeResponse"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    setTheme: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ThemeRequest"];
+            };
+        };
+        responses: {
+            /** @description The saved value. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ThemeResponse"];
+                };
+            };
+            /** @description theme wasn't "", "light", or "dark". */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    getFilterState: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The saved state, or `{}` if none has ever been saved. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FilterState"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    setFilterState: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["FilterState"];
+            };
+        };
+        responses: {
+            /** @description Saved. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The request body wasn't valid JSON, or exceeded the size this endpoint accepts. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    listAPITokens: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Every live token, oldest first. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["APIToken"][];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    createAPIToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["APITokenCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description Created — the only response that ever carries the raw token. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["APITokenCreateResponse"];
+                };
+            };
+            /**
+             * @description The request body wasn't valid JSON, label was blank, or
+             *     expiresAt wasn't in the future or was more than 366 days out.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    deleteAPIToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["PathTokenID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Revoked (or already gone). */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    ensureWebhook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebhookEnsureRequest"];
+            };
+        };
+        responses: {
+            /** @description The webhook now exists and is correctly configured. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /**
+             * @description The request body wasn't valid JSON, `fullName` wasn't
+             *     "owner/repo", no credentials are saved for that forge, or
+             *     that forge's client doesn't support managing webhooks at all.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the request as unauthorized — the saved token's scope doesn't cover managing webhooks, or it isn't an admin on that repo. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge reported the repo itself doesn't exist (or isn't visible to this token). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rate-limited the request. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge was unreachable, or answered with something this app couldn't classify more specifically. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    ignoreRepo: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RepoIgnoreRequest"];
+            };
+        };
+        responses: {
+            /** @description The repo is now ignored in the requested scope (or already was). */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /**
+             * @description The request body wasn't valid JSON, `fullName` wasn't
+             *     "owner/repo", or both `prs` and `issues` were false.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    unignoreRepo: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebhookEnsureRequest"];
+            };
+        };
+        responses: {
+            /** @description The repo is no longer ignored (or never was). */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The request body wasn't valid JSON, or `fullName` wasn't "owner/repo". */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    enableAutoUpdateBranch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebhookEnsureRequest"];
+            };
+        };
+        responses: {
+            /** @description Auto-update-branch is now on for this repo (or already was). */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The request body wasn't valid JSON, or `fullName` wasn't "owner/repo". */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    disableAutoUpdateBranch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebhookEnsureRequest"];
+            };
+        };
+        responses: {
+            /** @description Auto-update-branch is now off for this repo (or never was on). */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The request body wasn't valid JSON, or `fullName` wasn't "owner/repo". */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    mergePullRequest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PullRequestActionRequest"];
+            };
+        };
+        responses: {
+            /** @description Merged. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /**
+             * @description The request body wasn't valid JSON, `fullName` wasn't
+             *     "owner/repo", no credentials are saved for that forge, or
+             *     that forge's client doesn't support merging pull requests at
+             *     all.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the request as unauthorized — the saved token's scope doesn't cover merging, or it isn't allowed to merge on that repo. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge reported the repo or pull request doesn't exist (or isn't visible to this token). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the merge because the pull request isn't currently mergeable — a real conflict, or its state changed since the dashboard's last refresh. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rate-limited the request. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge was unreachable, or answered with something this app couldn't classify more specifically. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    closePullRequest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PullRequestActionRequest"];
+            };
+        };
+        responses: {
+            /** @description Closed. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /**
+             * @description The request body wasn't valid JSON, `fullName` wasn't
+             *     "owner/repo", no credentials are saved for that forge, or
+             *     that forge's client doesn't support closing pull requests at
+             *     all.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the request as unauthorized — the saved token's scope doesn't cover closing, or it isn't allowed to close on that repo. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge reported the repo or pull request doesn't exist (or isn't visible to this token). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rate-limited the request. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge was unreachable, or answered with something this app couldn't classify more specifically. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    updatePullRequestBranch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PullRequestActionRequest"];
+            };
+        };
+        responses: {
+            /** @description The forge scheduled the update as a background job rather than finishing it inline. Not a failure — a follow-up refresh reflects the result once it lands. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Updated. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /**
+             * @description The request body wasn't valid JSON, `fullName` wasn't
+             *     "owner/repo", no credentials are saved for that forge, or
+             *     that forge's client doesn't support updating pull request
+             *     branches at all.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the request as unauthorized — the saved token's scope doesn't cover updating the branch, or it isn't allowed to push on that repo. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge reported the repo or pull request doesn't exist (or isn't visible to this token). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the update because the branches can't be merged cleanly — a real conflict updating would need to resolve by hand. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rate-limited the request. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge was unreachable, or answered with something this app couldn't classify more specifically. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    postPullRequestDependabotAction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PullRequestDependabotActionRequest"];
+            };
+        };
+        responses: {
+            /** @description Comment posted. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /**
+             * @description The request body wasn't valid JSON, `action` wasn't "rebase"
+             *     or "recreate", `fullName` wasn't "owner/repo", no credentials
+             *     are saved for that forge, or that forge's client doesn't
+             *     support commenting on pull requests at all.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the request as unauthorized — the saved token's scope doesn't cover commenting, or it isn't allowed to comment on that repo. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge reported the repo or pull request doesn't exist (or isn't visible to this token). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the comment because of the pull request's current state. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rate-limited the request. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge was unreachable, or answered with something this app couldn't classify more specifically. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    postPullRequestRenovateRebase: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PullRequestActionRequest"];
+            };
+        };
+        responses: {
+            /** @description Label added. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /**
+             * @description The request body wasn't valid JSON, `fullName` wasn't
+             *     "owner/repo", no credentials are saved for that forge, or
+             *     that forge's client doesn't support labeling pull requests
+             *     at all.
+             */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the request as unauthorized — the saved token's scope doesn't cover labeling, or it isn't allowed to label on that repo. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge reported the repo or pull request doesn't exist, or (Forgejo only) the configured label doesn't exist on that repo — Forgejo's labels API takes an existing label's ID, not an arbitrary name, so it has to already be there. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rate-limited the request. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge was unreachable, or answered with something this app couldn't classify more specifically. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    getPullRequestChecks: {
+        parameters: {
+            query: {
+                forge: components["schemas"]["Forge"];
+                /** @description "owner/repo", matching a Repo.fullName from GET /api/dashboard. */
+                fullName: string;
+                /** @description Matching a PullRequest.number from GET /api/dashboard. */
+                number: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Every check/job found for that commit — empty when none were. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PullRequestChecksResponse"];
+                };
+            };
+            /** @description `number` wasn't an integer, `fullName` wasn't "owner/repo", no credentials are saved for that forge, or that forge's client doesn't support listing pull request checks at all. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rejected the request as unauthorized — the saved token's scope doesn't cover reading checks, or it isn't allowed to see that repo. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge reported the repo or pull request doesn't exist (or isn't visible to this token). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge rate-limited the request. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The forge was unreachable, or answered with something this app couldn't classify more specifically. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    listUsers: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Every registered user. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AdminUser"][];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The signed-in user isn't the designated admin. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    revokeUser: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                username: components["parameters"]["PathUsername"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Revoked. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description An admin can't revoke their own account through this endpoint. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The signed-in user isn't the designated admin. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No user is registered under that username. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    deleteUser: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                username: components["parameters"]["PathUsername"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Removed. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description An admin can't remove their own account through this endpoint. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The signed-in user isn't the designated admin. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No user is registered under that username. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    listInvites: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Every outstanding invite. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AdminInvite"][];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The signed-in user isn't the designated admin. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    createInvite: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AdminInviteCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description Created — the only response that ever carries the raw token. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AdminInviteCreateResponse"];
+                };
+            };
+            /** @description username or displayName was blank. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The signed-in user isn't the designated admin. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description That username is already registered. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    revokeInvite: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                token: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Revoked. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The signed-in user isn't the designated admin. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No outstanding invite with that id. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    health: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The process is up. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "status": "ok"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Health"];
+                };
+            };
+        };
+    };
+    getVersion: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The running version. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "version": "0.12.1"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Version"];
+                };
+            };
+        };
+    };
+    getDashboard: {
+        parameters: {
+            query?: {
+                /** @description A username that has shared their dashboard with the caller. Defaults to the caller's own. */
+                owner?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The current snapshot. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Dashboard"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description owner hasn't shared their dashboard with the signed-in user. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No user is registered under owner. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    streamDashboard: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /**
+             * @description An SSE stream. Each event's `data` field is a JSON-encoded
+             *     snapshot, identical in shape to GET /api/dashboard's
+             *     response body.
+             */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": components["schemas"]["Dashboard"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No background refresh is running yet for this user — Settings has never been saved. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    refreshDashboard: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The freshly refreshed snapshot. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Dashboard"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No background refresh is running yet for this user — Settings has never been saved. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    getSharing: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The current sharing relationships. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SharingResponse"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    shareWith: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                username: components["parameters"]["PathUsername"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Shared. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Can't share your own dashboard with yourself. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No user is registered under that username. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    unshareWith: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                username: components["parameters"]["PathUsername"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description No longer shared. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No valid session cookie was presented. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    receiveGitHubWebhook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                webhookToken: components["parameters"]["PathWebhookToken"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": Record<string, never>;
+            };
+        };
+        responses: {
+            /** @description Signature verified; a refresh was triggered. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The X-Hub-Signature-256 header was missing or didn't verify against this user's webhook secret. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No user's webhook token matches webhookToken. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    receiveForgejoWebhook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                webhookToken: components["parameters"]["PathWebhookToken"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": Record<string, never>;
+            };
+        };
+        responses: {
+            /** @description Signature verified; a refresh was triggered. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Both signature headers were missing, or neither verified against this user's webhook secret. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No user's webhook token matches webhookToken. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+}
+//# sourceMappingURL=schema.d.ts.map