11783 lines
440 KiB
TypeScript
11783 lines
440 KiB
TypeScript
/**
|
||
* This file was auto-generated by openapi-typescript.
|
||
* Do not make direct changes to the file.
|
||
*/
|
||
|
||
export interface paths {
|
||
"/api/v1/nodes": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** List execution nodes (administrator). */
|
||
get: operations["executionNodes"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/migrations": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Read durable migration progress. */
|
||
get: operations["latestWorldMigrationStatus"];
|
||
put?: never;
|
||
/** Migrate an already stopped world; persistent lock survives controller restart. */
|
||
post: operations["startWorldMigration"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/migrations/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Read durable migration progress. */
|
||
get: operations["worldMigrationStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/migrations/{id}/retry": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Retry a failed migration, retaining the source and stopped state. */
|
||
post: operations["retryWorldMigration"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/healthz": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Liveness probe.
|
||
* @description Unauthenticated on both faces; kubelet and Cloudflare hold no token.
|
||
*/
|
||
get: operations["healthz"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/readyz": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Readiness probe (internal face only — readiness is an internal concern). */
|
||
get: operations["readyz"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/metrics": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Prometheus metrics (felis_* collectors) on the internal face.
|
||
* @description Scrape-only infrastructure route, not a product API: the internal listener is ClusterIP-only and a Prometheus scrape carries no token, the same stance as the probes. Serves the felis_* exposition documented in troubleshooting §14; the external face never serves it.
|
||
*/
|
||
get: operations["metrics"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/session/minecraft/hasJoined": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Multi-source session verifier (Felis-nano hasJoined multiplexer).
|
||
* @description Velocity is pointed here with -Dmojang.sessionserver and sends the request itself. Unauthenticated — the vanilla sessionserver protocol carries no token. The query is fanned out to the configured Yggdrasil roots in priority order (the Mojang identity source first); the first source to validate the serverId hash wins. A non-identity source's self-asserted UUID is rewritten into a per-source namespace (UUIDv3) before return, so it can never land in Mojang's UUID space. A rejected or barred login is 204, which Velocity answers with its online-mode-only kick. Any other non-200 status makes Velocity report the auth servers as down.
|
||
*/
|
||
get: operations["hasJoined"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** List all servers (velocity route table). */
|
||
get: operations["listServers"];
|
||
put?: never;
|
||
/**
|
||
* Create a server (admin).
|
||
* @description Requires a staff session on the operator console host; the image must be whitelisted. An image in the platform registry is stored pinned to the digest its tag names at creation (name:tag@sha256:…), so a later push over the tag never moves the server; 400 image_not_in_registry when the registry lacks the tag, 503 registry_unavailable when it cannot be asked.
|
||
*/
|
||
post: operations["createServer"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/servers/{name}/ready": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Backend readiness callback — the server reports it is accepting players. */
|
||
post: operations["serverReadyCallback"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/submissions/{id}/context": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Stream a submission's stored build-context tarball to the build Pod.
|
||
* @description The build Job's fetch initContainer cannot mount the control-plane uploads PVC (a PVC does not cross namespaces) and holds no object-store credentials, so the API that stored the blob streams it here. Served on the internal face (service token, no Zero Trust).
|
||
*/
|
||
get: operations["internalSubmissionContext"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/file-uploads/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Stream one staged file upload to the Job landing it (one-time bearer token).
|
||
* @description PUT /api/v1/servers/{name}/files/upload stages the body on felis-api's disk and creates a Job to land it in the world volume; the Job fetches the bytes here. The Job holds no service token, so the route is public on the internal face and the bearer token minted with the upload is the whole check. The token opens its upload once. An unknown id, a wrong or missing token and a spent token are all the same 404, so the route says nothing about which uploads exist. An upload session committed through POST …/files/uploads/{id}/commit is fetched here the same way, under the session id; it stays staged until its Job reports the file landed (DELETE), so a Job that failed at any point can be committed again.
|
||
*/
|
||
get: operations["internalFileUpload"];
|
||
put?: never;
|
||
post?: never;
|
||
/**
|
||
* The Job reports a staged upload landed (the same one-time bearer token).
|
||
* @description Sent once the file is in place. An upload session is then dropped from felis-api's disk; a single-request upload goes when its request ends in any case. Only the token of the session's latest commit is taken. As for the fetch, every refusal is the same 404.
|
||
*/
|
||
delete: operations["internalFileUploadLanded"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/file-browser/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Exchange a read-only file Job's result for its next command.
|
||
* @description Internal face only. A random bearer token scopes the worker to one world and a four-minute session; idle workers exit after 45 seconds. The first request sends an empty object. Later requests return the previous command's id and result or error. This endpoint dispatches only reads already authorized by the external file API.
|
||
*/
|
||
post: operations["internalFileBrowser"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/exports/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
/**
|
||
* Hand one export's archive over for download (one-time bearer token).
|
||
* @description The export Job PUTs the archive or file here, always chunked, with its size as X-Felis-Export-Length when it knows it and, once the body has ended, the SHA-256 of all it sent as the Content-Digest trailer (sha-256=:<base64>:). felis-api holds the last bytes back from the browser until the bytes it received number and hash as the Job said, so a body changed on the way, or one without the trailer, ends the download short and the browser reports it failed. The Job holds no service token, so the route is public on the internal face and the bearer token minted with the export is the whole check; an unknown id, a wrong or missing token and a token already used are all the same 404. The request then waits, body unread, up to 90 seconds for the owner's browser to open the download, and is read at the browser's pace: the 16 KiB/s minimum body rate does not apply, and the body fails only after 2 minutes without a byte. It answers once the download has ended.
|
||
*/
|
||
put: operations["internalExportUpload"];
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/servers/{name}/join-event": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Player-join event by online-mode UUID (activity tracking / idle reset). */
|
||
post: operations["joinEvent"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/servers/{name}/wake": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Domain-autostart wake driven by velocity for a joining player (spec §9.1).
|
||
* @description velocity holds no web Principal, so it drives the wake lever with its service token, identifying the player by online-mode UUID. Gated by the server's autostartPolicy and the per-server wake cooldown. A server whose start failed with its automatic retries spent answers 409 start_failed: a join never resets the retry budget, so velocity queues no one for it.
|
||
*/
|
||
post: operations["internalWake"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/servers/{name}/status": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Server status projection (velocity polls this after a wake). */
|
||
get: operations["internalStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/servers/{name}/claim": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Lobby "Claim & Start" by online-mode UUID (spec §12).
|
||
* @description The felis-paper lobby holds no token, so velocity claims on its behalf, binding the unowned server to the player's linked account.
|
||
*/
|
||
post: operations["internalClaim"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/servers/{name}/menu": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Lobby menu projection — status plus the ownership-derived `claimable`. */
|
||
get: operations["internalMenuStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/player/menu-access/{mc_uuid}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* What one player may start, for every user server — the lobby menu's per-player verdicts.
|
||
* @description One call per menu open; each tile's live state stays in the shared per-server projection (…/menu). A server that is up is open to every linked player, so the lobby shows Join there whatever the verdict. The verdicts follow the internal wake's gates without the transient ones (cooldown, running-server cap): `retiring` (given up or being deleted), `start_failed` (automatic restarts spent), `owner` (the player's own), `wake` (the autostart policy admits the player), `owner_only`, and `allowlist` (the player is not on the list).
|
||
*/
|
||
get: operations["internalMenuAccess"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/account/link/code": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Mint a one-time account-link code for a verified online-mode UUID (spec §10).
|
||
* @description Internal-only — the code is born from a UUID the web never holds.
|
||
*/
|
||
post: operations["createLinkCode"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/account/link/status/{mc_uuid}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Poll whether an in-game UUID has finished linking — the QR scan-to-login completion check (spec §B3).
|
||
* @description Internal-only, read-only. After a new player scans the QR-encoded link code and the web verify writes the durable account_links row, velocity polls this for the UUID it minted against and admits the player on linked:true. Keyed by the verified UUID (not the scanned code), so it consumes nothing and is safe to poll repeatedly; an unlinked or never-seen UUID returns linked:false. The response is deliberately just the boolean — the plugin keys everything on the UUID it already holds, so no identity detail crosses back.
|
||
*/
|
||
get: operations["linkStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/account/migrate/start": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Put the account linked to a verified in-game UUID into migrate mode (spec §B3 inherit, in-game side).
|
||
* @description Internal-only. The in-game /felis migrate command calls this for the running player's verified UUID: it resolves the linked account and opens a fresh migration in the initiated state, superseding any earlier unfinished attempt by the same source. The web side then drives a fresh step-up confirmation. The transfer itself moves server ownership only — never the mc_uuid link nor web credentials — so this endpoint starts a flow, it does not move anything.
|
||
*/
|
||
post: operations["migrateStart"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/player/reclaim": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Record a Mojang-priority username reclaim — bar the squatter UUID and stash its data (spec §B3).
|
||
* @description Internal-only. Velocity records a username-collision reclaim: the non-genuine squatter UUID is barred and its world/player data stashed for a 30-day window so a new account can inherit it. Idempotent — a repeat reclaim of an already-barred UUID is a no-op. The bar is keyed by UUID, never the contested name, so the genuine Mojang player always passes.
|
||
*/
|
||
post: operations["reclaimUsername"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/player/blacklist/{mc_uuid}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Report whether an in-game UUID was barred by a prior reclaim (spec §B3).
|
||
* @description Internal-only. The velocity login gate calls it to reject a barred squatter before letting them in; the genuine Mojang UUID — same username, different UUID — is never on the list and always passes.
|
||
*/
|
||
get: operations["checkUsernameBlacklist"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/op-login/pending": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List live pending op.console login requests, oldest first (spec §B).
|
||
* @description Internal-only. Lists the requests awaiting an in-game vouch. Today no plugin consumes it — the staff member reads the request id off the op.console page and an admin approves it with /felis web op approve <id>; the route exists so velocity can later push the waiting list to online admins. No pending request is secret to the operator crew.
|
||
*/
|
||
get: operations["opLoginPending"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/op-login/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Show an in-game admin whose op.console login a request is (spec §B).
|
||
* @description Internal-only. velocity's /felis web op approve <code> reads this and shows the admin the account, its address, and when and from where the sign-in was started, then asks them to confirm by typing the account name (see approve). The approver's online-mode UUID gets the same check as approve (a linked admin or owner, else 403 not_admin), since the command runs for any player and a staff address must not be readable by one. A request that is unknown, expired, approved or consumed is 404.
|
||
*/
|
||
get: operations["opLoginShow"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/op-login/{id}/approve": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Record an in-game admin's vouch for a pending op.console login (spec §B).
|
||
* @description Internal-only second factor: velocity submits the online-mode UUID of the in-game admin running /felis web op approve <code> <username>, and the account name they typed after seeing the request (GET /api/v1/internal/op-login/{id}). The API resolves the UUID to a linked admin or owner account (else 403 not_admin), requires the typed name to match the request's account ignoring case (else 409 op_login_mismatch, audited, request left pending) and flips the request approved. A missing or no-longer-pending request is 404. Self-approval is allowed — an online staff member vouching as their own admin identity is a genuine second factor distinct from the mailbox.
|
||
*/
|
||
post: operations["opLoginApprove"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/internal/servers/{name}/backup": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Break-glass on-demand world backup (service token; server must be stopped).
|
||
* @description The break-glass console (root on the node, holding the service token) POSTs here to snapshot a stopped world while the API is alive — it goes through the API rather than direct-to-CRD because rendering the backup Job needs deployment coordinates only felis-api holds. Same RWO stopped-gate and async 202 as the external backupNow; there is no Principal (trusted machine caller), and the action is audited to "break-glass".
|
||
*/
|
||
post: operations["internalBackupNow"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/wake": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Wake your own server.
|
||
* @description On a server whose start Failed (phase Failed, desiredState Running) this is a retry: the operator recreates the pod and starts it over with a fresh automatic-restart budget. It is audited as retry_start.
|
||
*/
|
||
post: operations["wake"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/stop": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Stop your own server. */
|
||
post: operations["stop"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/emergency-stop": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Scale an owned game workload to zero independently of Operator and RCON.
|
||
* @description Owner only; fresh authentication and exact name confirmation required. A 202 acknowledges scaling, not process exit. Normal Pod termination grace is retained.
|
||
*/
|
||
post: operations["emergencyStop"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/restart": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Restart your own running server, or a system service as staff.
|
||
* @description Records a durable request for the operator to gracefully recreate the game pod. Desired state remains Running. A concurrent stop supersedes the request; maintenance blocks admission.
|
||
*/
|
||
post: operations["restart"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/claim": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Claim an unowned server for your linked account. */
|
||
post: operations["claim"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/command": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Run a console command via RCON (spec §8 write). Owner/admin only.
|
||
* @description The RCON password is never accepted or returned (spec §286).
|
||
*/
|
||
post: operations["command"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/console": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Stream the running pod's log over SSE (spec §8 read, §262). Owner/admin only. */
|
||
get: operations["serverConsole"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/access/whitelist": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List whitelisted players via RCON (spec §7). Owner/admin only.
|
||
* @description Runs "whitelist list" against the live server and returns a best-effort parse plus the raw reply. The RCON password is never accepted or returned (spec §286).
|
||
*/
|
||
get: operations["accessWhitelistList"];
|
||
put?: never;
|
||
/**
|
||
* Add or remove a player from the whitelist (spec §7). Owner/admin only.
|
||
* @description Translates to the RCON "whitelist add|remove <player>" command. The player name is validated against the Minecraft username charset before it is built into a command. The RCON password is never accepted or returned (spec §286).
|
||
*/
|
||
post: operations["accessWhitelist"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/access/players": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List online players via RCON (spec §7). Owner/admin only.
|
||
* @description Runs "list" against the live server and returns the online/max tally, a best-effort parse of the online player names, and the raw reply. This is the only source of WHO is online — Status.Players carries the count alone. The RCON password is never accepted or returned (spec §286).
|
||
*/
|
||
get: operations["accessPlayers"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/access/ban": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List banned players via RCON (spec §7). Owner/admin only.
|
||
* @description Runs "banlist" against the live server and returns a best-effort parse plus the raw reply. The RCON password is never accepted or returned (spec §286).
|
||
*/
|
||
get: operations["accessBanList"];
|
||
put?: never;
|
||
/**
|
||
* Ban or pardon a player (spec §7). Owner/admin only.
|
||
* @description Translates to the RCON "ban|pardon <player>" command. Carries no reason field (a free-text reason would be an injection vector; the audit log records intent). The RCON password is never accepted or returned (§286).
|
||
*/
|
||
post: operations["accessBan"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/access/kick": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Kick a player off the running server (spec §7). Owner/admin only.
|
||
* @description Translates to the RCON "kick <player>" command. Unlike ban it does not block rejoining. Carries no reason field (a free-text reason would be an injection vector; the audit log records intent). The RCON password is never accepted or returned (spec §286).
|
||
*/
|
||
post: operations["accessKick"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/access/permission": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Set or unset a LuckPerms permission node (spec §7). Owner/admin only.
|
||
* @description Translates to "lp user <player> permission set <node> <true|false> [world=<world>]" (or unset). An omitted value defaults to true (grant), not false (deny). Player, node and world are charset-validated before the command is assembled. The RCON password is never accepted or returned (spec §286).
|
||
*/
|
||
post: operations["accessPermission"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/access/group": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Add or remove a player's LuckPerms parent group (spec §7). Owner/admin only.
|
||
* @description Translates to "lp user <player> parent add|remove <group>". Player and group are charset-validated before the command is assembled. The RCON password is never accepted or returned (spec §286).
|
||
*/
|
||
post: operations["accessGroup"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/access/luckperms/{player}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Read a player's LuckPerms groups and permission nodes (spec §7). Owner/admin only.
|
||
* @description Translates to "lp user <player> permission info" over RCON and parses the paginated, colour-coded reply (up to 10 pages) into structured entries. Parent groups (granted group.<name> nodes without a world context) are split out from plain permission nodes. The raw concatenated RCON output is echoed back for anything the parser cannot represent.
|
||
*/
|
||
get: operations["accessLuckPermsInfo"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/allowlist": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* The server's wake allowlist, newest first. Owner/admin only.
|
||
* @description Who may wake the server while it sleeps under autostartPolicy=allowlist. A player lands here by joining the server once; entries whose wake right was taken away stay listed with can_wake false, so it can be given back. Felis keeps this list itself, so it answers whether the server is running or not. A change of owner (claim, reaper release, account deletion) empties it.
|
||
*/
|
||
get: operations["listAllowlist"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/allowlist/{uuid}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
/**
|
||
* Take a player's wake right away or give it back. Owner/admin only.
|
||
* @description can_wake false keeps the entry on the list with its wake right revoked, so the player's next join does not restore it; true gives it back. Repeating either is harmless. Audited as allowlist.revoke / allowlist.restore.
|
||
*/
|
||
put: operations["setAllowlistWake"];
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/retirement": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
/**
|
||
* Give the server up (owner) or delete it (admin). The reaper carries it out.
|
||
* @description The server is stopped and the request recorded; the reaper, the one component that deletes a world, carries it out on its next daily run. It archives the world as a released backup (kept for the reaper's retention, recorded against the owner), deletes the world volume and releases the server for anyone to claim; with delete it also removes the server, which frees its name and subdomain. Until then the server cannot be woken or claimed and still counts against the owner's quota, and the request can be cancelled. Repeating it keeps the first request time, and a deletion stays a deletion. confirm must repeat the server's name. Audited as server.release / server.delete.
|
||
*/
|
||
put: operations["retireServer"];
|
||
post?: never;
|
||
/**
|
||
* Cancel a pending retirement. Only an admin cancels a deletion.
|
||
* @description The server stays stopped; its owner starts it again when they want it. Cancelling when nothing is pending changes nothing. Audited as server.retire_cancel.
|
||
*/
|
||
delete: operations["cancelRetire"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/status": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Status of a server; the full record for its owner and staff.
|
||
* @description Anyone signed in may ask. The owner and staff get the whole projection; anyone else gets what the game's own server list shows: name, subdomain, displayName, phase, ready, playersOnline and playersMax.
|
||
*/
|
||
get: operations["status"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/options": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Identifier-first login discovery — which methods can this email use (spec §B,
|
||
* @description Public, pre-session discovery for the SPA's identifier-first form: given a typed email, report which console login methods the account can use (passkey and/or email-OTP) so the UI prompts for the right authenticator. This is the deliberate counter-slice to the anti-enumeration login doors — the ONE sanctioned place account existence is disclosed, so an unknown address returns an empty methods array. It never reveals staffness: methods are computed identically for every resolved account (no role branch), so a staff and a player address in the same credential state return byte-identical bodies. passkey is offered only when a verifier is wired. Sends no mail and mutates nothing; bounded by the per-address sign-in rate limit (429 rate_limited). Gated on local_auth_enabled.
|
||
*/
|
||
post: operations["authOptions"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/passkey/login/begin": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Begin a passwordless passkey (WebAuthn) login (spec §14, §B).
|
||
* @description First leg of the public, pre-session passkey assertion door: the caller supplies the email that selects the account and, on success, receives the raw PublicKeyCredentialRequestOptions to hand to navigator.credentials.get(). The matching challenge is stashed server-side and redeemed by finish. Mounted Public (no prior principal) and gated on local_auth_enabled. An unknown address and a known account with no enrolled passkey both return the SAME 400 no_passkey, so the door is not an existence oracle; the per-address sign-in rate limit bounds probing. Each begin stashes a ceremony of its own beside the account's other live ones, so a begin by anyone who knows the address never cancels its owner's. One network (an IPv4 address or IPv6 /48) holds at most 32 live login challenges (429 too_many_challenges past that).
|
||
*/
|
||
post: operations["passkeyLoginBegin"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/passkey/login/finish": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Complete a passkey (WebAuthn) login and mint a session (spec §14, §B).
|
||
* @description Second leg of the public passkey door: the caller returns the email (to re-select the account) and the raw navigator.credentials.get() assertion. The live login challenge whose value the assertion signed (response.clientDataJSON) is consumed atomically and the assertion is verified against it; on success a host-only felis_session cookie is minted. Both players and staff may log in this way — a passkey is a two-factor authenticator (possession + user verification), strong enough to stand alone without the in-game approval op-login requires. User verification is checked per credential: the passkey must have verified the user when it was bound, and this assertion must verify the user now. Every failure mode (unknown address, no live challenge for the signed value, expired challenge, bad assertion, a credential or assertion without user verification, a cloned authenticator) collapses into one uniform passkey_login_invalid, so the door reveals nothing.
|
||
*/
|
||
post: operations["passkeyLoginFinish"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/passkey/login/discoverable/begin": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Begin a usernameless (discoverable) passkey login (spec §14, §B, task
|
||
* @description First leg of the truly from-zero passkey door: unlike the email-first sibling above, the caller supplies NO identifier — the request has no body (only the application/json Content-Type is required as the cross-origin CSRF guard). The response is the WebAuthn PublicKeyCredentialRequestOptions with an EMPTY allowCredentials, plus an opaque login_id: the authenticator picks a resident credential it holds for this RP and the account is revealed only by the userHandle inside the signed assertion at finish. The challenge cannot be user-keyed, so it is stashed under login_id in a non-user-keyed store and echoed back at finish. Mounted Public and gated on local_auth_enabled. One client is bounded by the per-address sign-in rate limit (429 rate_limited), one network (an IPv4 address or IPv6 /48) to 32 live challenges, and the table by a hard global cap of 16384 (both 429 too_many_challenges). Inert for a credential until its owner enrolls a resident passkey; email-OTP and username-first passkey remain the fallbacks, so no authenticator is ever locked out.
|
||
*/
|
||
post: operations["passkeyLoginDiscoverableBegin"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/passkey/login/discoverable/finish": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Complete a usernameless (discoverable) passkey login and mint a session (spec §14, §B, task
|
||
* @description Second leg of the from-zero door: the caller returns the opaque login_id from begin (the only link to the stashed challenge, since it is not user-keyed) and the raw navigator.credentials.get() assertion — and NOTHING that names an account. The stashed challenge is consumed atomically and the assertion is verified against it; the account is resolved from the authenticator-revealed userHandle (the account's stable id), never from anything the client supplied, and the session is minted for the account the assertion actually resolved AND verified to. Both players and staff may log in this way, with the same per-credential user-verification check as the username-first door. Every failure mode — a missing/expired/consumed login_id, a bad assertion, no user verification, a cloned authenticator, AND a userHandle that resolves to no account — collapses into one uniform passkey_login_invalid, so the door reveals nothing (not even whether the handle was well-formed).
|
||
*/
|
||
post: operations["passkeyLoginDiscoverableFinish"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/email/start": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Begin a passwordless email-OTP login — mail a one-time code (spec §B).
|
||
* @description Public, pre-session console door: the caller supplies an email and, if it resolves to a verified account, a one-time code is mailed under the login purpose. An address with no account returns the SAME 202 with no code minted, and the per-recipient cooldown is kept on that path too, so probing reveals nothing (existence is learnt only at the sanctioned /auth/options oracle). One code is mailed per recipient per minute: a start inside that window gets the same 202 (expires_at of the live code) and mails nothing. A start never cancels the codes already mailed; the three newest live codes all work, and signing in with one spends the rest. An account that spent its daily wrong-code budget (10 per 24h, across every code) also gets the same 202 and no mail until the window ends. Gated on local_auth_enabled.
|
||
*/
|
||
post: operations["loginEmailStart"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/email/verify": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Redeem an email-OTP login code into a session (spec §B).
|
||
* @description Public, pre-session: resolves the address to an account, verifies the code under the login purpose, and on success mints a host-only felis_session. An unknown address, a wrong or expired code, and an attempt-exhausted code all return the IDENTICAL 400 invalid_code, so the door is not an existence or lockout oracle. The 10th wrong code in 24h locks the door for that account until the window ends (the right code then also reads as invalid_code); the owner is told by mail once, and the lock is audited as auth.otp.locked. Staff are refused (403) — but only AFTER a valid code is redeemed, so only the account owner can ever reach that refusal.
|
||
*/
|
||
post: operations["loginEmailVerify"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/op-login/start": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Begin an op.console staff login — mail an OTP, open an approval request (spec §B).
|
||
* @description Public, pre-session first leg of the two-factor operator door: resolves the staff address, opens an op_login request, and mails a one-time code under the op_login purpose, returning the request handle the browser polls. A non-staff or unknown address gets the SAME 202 with a random, non-persisted handle and no mail, so this never becomes a staff-enumeration oracle. A staff account that spent its daily wrong-code budget gets the same neutral 202. One code is mailed per recipient per minute: a staff start inside that window opens a real request but mails nothing, and the code already in the inbox finishes it. A start never cancels the codes already mailed (the three newest live codes all work). Gated on local_auth_enabled.
|
||
*/
|
||
post: operations["opLoginStart"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/op-login/status/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Poll whether an op.console login request has been approved in-game (spec §B).
|
||
* @description Public, pre-session read the browser polls after start. Returns approved:true only for a genuinely approved, live, unconsumed request; every other case — unknown, expired, denied, or already-consumed handle — reads approved:false, so a fabricated handle polls false forever and only an in-game admin vouch can flip it true.
|
||
*/
|
||
get: operations["opLoginStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/op-login/finish": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Redeem an approved op.console request plus its mailed code into a staff session (spec §B).
|
||
* @description Public, pre-session final leg: mints a host-only staff session only when BOTH factors have landed — the request is approved-and-live AND the mailed code verifies. Every failure (unknown handle, not-yet-approved, wrong or locked code, an account past its daily wrong-code budget, an account disabled or deleted since the start, lost race) collapses into one uniform 400 op_login_invalid, so a code-less caller learns nothing. Admin is re-asserted before the session is issued.
|
||
*/
|
||
post: operations["opLoginFinish"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/setup/redeem": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Redeem a one-time setup token into a lockdown session (spec §B).
|
||
* @description Public, pre-session first-run door: consumes the one-time setup token minted by the felis TUI (stored and looked up by SHA-256 hash, like session cookies), mints a host-only felis_session, and returns the remaining setup steps so the SPA can drive the wizard. An unknown, consumed, or expired token returns a uniform 400 setup_token_invalid. Gated on local_auth_enabled. The token is spent in the same transaction that stores the session, so a redemption that fails with 500 leaves the link working for another try.
|
||
*/
|
||
post: operations["setupRedeem"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/setup/status": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Report the caller's own setup progress (spec §B).
|
||
* @description App-tier read the SPA polls after each setup wizard step (email verify, passkey enroll) to decide whether the first-run lockdown can lift. It reads only the principal's own state and is reachable during setup lockdown (the rest of the API is fenced until setup completes).
|
||
*/
|
||
get: operations["setupStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/owner-status": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Report whether an Owner has been created on this install.
|
||
* @description Public, pre-session probe the sign-in page reads on load. Until `felis setup` creates an Owner, local sign-in is off and every login door answers 403 local_auth_disabled; the page then explains that no Owner exists and how to create one instead of offering the doors. It discloses only whether the install is still unclaimed, and claiming it needs root on the host. It is not gated on local_auth_enabled and does not draw on the login doors' per-address rate limit.
|
||
*/
|
||
get: operations["ownerStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/logout": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Revoke the current local session and clear the cookie.
|
||
* @description Revokes the presented session and clears the cookie (spec §B). Mounted Public and idempotent: it reads the cookie directly, so it works even when the session has already expired and never errors on a missing one.
|
||
*/
|
||
post: operations["logout"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/auth/bind": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Redeem a Bind Code into a player account + session (public console bootstrap, spec §10/§B).
|
||
* @description The one public, pre-account entrypoint of the player console (console.<root_domain>): an account-less player redeems the one-time Bind Code they generated in the in-game Login Lobby, and the platform creates their player account (role=user), binds it to the verified in-game UUID, and mints a host-only session cookie. Safe to expose unauthenticated because the code is minted internal-face only, against an online-mode-verified UUID, with a short TTL and single use — possession already proves control of a Minecraft identity. An already-linked player UUID logs that player back in (idempotent); a UUID that belongs to staff is refused (403) — operators authenticate at op.console behind Zero Trust, so this never mints a session for an admin identity. Requires local sessions to be enabled (same toggle as login).
|
||
*/
|
||
post: operations["bindRedeem"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/me": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* The caller's own identity and tier (drives panel navigation).
|
||
* @description Returns the authenticated principal's user id, email, role and the server-computed is_admin (Principal.IsAdmin(): role admin reached on the operator console host). The panel reads this once at boot to decide which surfaces to render. It is UX truth, not a security control — admin routes are independently gated server-side, so a hidden nav item never widens access.
|
||
*/
|
||
get: operations["me"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/me/servers": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** List the servers the caller owns or may claim. */
|
||
get: operations["myServers"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/settings/node-control": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Read host node-service availability and persistent task history (Owner). */
|
||
get: operations["nodeTasks"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/settings/node-control/tasks": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Execute fixed host node operation (Owner, fresh reauthentication).
|
||
* @description Tasks are serialized, audited and persisted on the controller. The host verifies stopped workloads and SSH trust before enrollment or admission. Bootstrap credentials never cross the external API. Server starts fail closed during node operations and when the configured host service cannot report its state.
|
||
*/
|
||
post: operations["startNodeTask"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/settings/node-control/tasks/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Read task stage, terminal error and bounded execution log (Owner). */
|
||
get: operations["nodeTask"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/settings/node-control/tasks/{id}/retry": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Create a new attempt from a failed task (Owner, fresh reauthentication). */
|
||
post: operations["retryNodeTask"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/settings/wake-policy": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Read platform startup policy (Owner). */
|
||
get: operations["getWakePolicy"];
|
||
/**
|
||
* Save platform startup policy (Owner, fresh reauthentication).
|
||
* @description Atomically persists an override shared by all replicas. The admission limit applies to panel, in-game and scheduled starts without restarting. It does not stop existing servers or reserve memory. Wake cooldown applies to panel and in-game wakes.
|
||
*/
|
||
put: operations["setWakePolicy"];
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/settings/auth-sources": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Read authentication sources (Owner). */
|
||
get: operations["getAuthSources"];
|
||
/**
|
||
* Save authentication sources (Owner, fresh reauthentication).
|
||
* @description Atomically persists an override in platform_settings. It applies to the next login and role lookup on every API replica without restarting; existing players stay online. Tags identify permanent UUID namespaces; retain every saved tag and disable unwanted sources. Mojang remains built-in and trusted, while configured sources always remain third-party. Nano remains TOML-only.
|
||
*/
|
||
put: operations["setAuthSources"];
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/settings/auth-sources/test": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Probe a hasJoined endpoint (Owner).
|
||
* @description Checks an unsaved source with a fresh random serverId. A healthy endpoint returns 204 for a session that never joined. Uses a five-second timeout, verified TLS and no redirects. This tests connectivity and hasJoined behavior, not launcher login or profile lookup. Does not save configuration.
|
||
*/
|
||
post: operations["testAuthSource"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/updates/window": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Read the Owner-set auto-update maintenance window (Owner).
|
||
* @description Felis applies no update on its own. `felis update` checks versions and prints an explicit apply command. `felis update --apply` reads this platform-wide [start,end) window before backup and before installation, refusing outside it unless `--now` explicitly starts manual maintenance. An unreadable window is always a refusal, including with `--now` or `--force`. An unset window reads back as {start:null,end:null}.
|
||
*/
|
||
get: operations["getUpdateWindow"];
|
||
/**
|
||
* Set or clear the SysAdmin auto-update maintenance window (Owner).
|
||
* @description Persist the maintenance window as an absolute [start,end) interval. Both ends must be set with end strictly after start, or both null to clear the window to unset. A half-set (exactly one end) or inverted/empty (end not after start) body is rejected 400, mirroring the decision core's fail-closed Window so a malformed schedule can never be stored. No forced auto-update: setting a window only permits an apply inside it; outside, a Scheduled component degrades to notify.
|
||
*/
|
||
put: operations["setUpdateWindow"];
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/platform/db-backup": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Freshness of the newest control-plane database backup (Owner).
|
||
* @description What the host's felis-db-backup.timer (or a manual `felis db backup`) last recorded in platform_settings. last is null before the first backup; stale is true then, and whenever the newest daily backup (last.daily_at) is missing or older than max_age_seconds. Read-only: backups run on the host, never through the API.
|
||
*/
|
||
get: operations["getDBBackup"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/updates/report": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* The newest recorded version check of every tracked component (Owner).
|
||
* @description What `felis update --record` last stored in platform_settings; the installer's felis-update-check.timer runs it daily on the host, where the installed versions are readable. report is null before the first check; stale is true then, and whenever the check is older than max_age_seconds. Read-only: Felis applies no update on its own.
|
||
*/
|
||
get: operations["getUpdateReport"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/fleet": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* The SysAdmin cockpit's fleet-wide server list (admin; cockpit extension, not a spec §7 route).
|
||
* @description Every MinecraftServer's CRD+status lifecycle view, for the SysAdmin FleetTable. Admin-tier — it reads every owner's server. A path distinct from the internal velocity GET /api/v1/servers because one {method, path} cannot carry both the service and admin tiers. Lifecycle is CRD truth (§1); the owner is the only business field, joined READ-ONLY from Postgres (§6) for display — best-effort, so a Postgres blip degrades to owner-less rows.
|
||
*/
|
||
get: operations["fleet"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/backups": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List world backups (admin sees all; a user sees only worlds they formerly owned).
|
||
* @description One page of the present backups in the caller's scope, newest first. server narrows the page to one server's backups inside that scope; it never widens it.
|
||
*/
|
||
get: operations["listBackups"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/backups/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
post?: never;
|
||
/**
|
||
* Delete one world backup (admin, or the user who owned the world).
|
||
* @description The backup leaves every list, restore and the backup budget at once; the reaper's next daily run deletes the archive and the off-site copy's next sync removes the bucket's copy. A user gets 404 for a backup outside their scope, as their list never shows it. Refused while a restore on the backup's server may still read it.
|
||
*/
|
||
delete: operations["deleteBackup"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/restore-backup": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Restore a world from a backup (owner-or-admin plus a former-owner match).
|
||
* @description By default the restore starts with a safety snapshot: a backup of the data volume as it is now (reason "pre_restore", the newest 3 kept per server), and the restore Job starts only once that backup has succeeded. If the snapshot fails the restore is given up and the world is left as it was. GET /servers/{name}/jobs shows the snapshot as a backup job whose then_restore says what became of the restore. The world stays locked from the request until the restore Job finishes. Pass safety_snapshot false to restore straight away.
|
||
*/
|
||
post: operations["restoreBackup"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/backup": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Back up a server's data volume on demand (owner-or-admin; server must be stopped).
|
||
* @description Snapshots the server's whole data volume (worlds, config, plugins/mods, jars, libraries — not just world folders) into the archive store as a first-class world_backups row (reason "manual"), restorable later like an inactivity backup. A restore replaces the volume with the archive. The world PVC is RWO and held by a running server, so the server must be fully stopped first (409 not_stopped otherwise). The backup runs asynchronously as a Job, so success is 202 (backing_up).
|
||
*/
|
||
post: operations["backupNow"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/backups/{id}/export": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Start downloading one backup (owner-or-admin plus a former-owner match).
|
||
* @description Starts a Job that reads the archive from the backup store and hands it to felis-api, which streams it to the browser (poll GET /exports/{ticket}, then open its download). The Job checks the archive against the sha256 recorded when it was written as it streams; a mismatch cuts the download off short of its end. On the way out config/paper-global.yml (the cluster's forwarding secret) is left out and server.properties has its rcon.password and forwarding-secrets redacted, so the download carries no Content-Length. A user gets 404 for a backup outside their scope, as their list never shows it. One export per user at a time, 2 across the install, 6 per user per hour.
|
||
*/
|
||
post: operations["exportBackup"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/world/export": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Start downloading a stopped server's world as it is now (owner-or-admin).
|
||
* @description Starts a Job that archives the server's data volume, read-only, and hands it to felis-api, which streams it to the browser (poll GET /exports/{ticket}, then open its download). The server must be fully stopped, and it cannot start until the download has ended or the Job's 2 hour deadline passes. The same two files are guarded as in a backup export, matched by the file itself, so a link to either under another name is guarded too. Same limits as a backup export.
|
||
*/
|
||
post: operations["exportWorld"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/exports/{ticket}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Where an export stands (the user who started it only).
|
||
* @description The panel polls this until the state reads ready, then opens the download. Another user's ticket is 404, as an unknown one is.
|
||
*/
|
||
get: operations["exportStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/exports/{ticket}/download": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Download a ready export (once, by the user who started it).
|
||
* @description The first request spends the ticket, whatever becomes of it. The archive streams as the Job sends it, with Content-Length when it is known; a download that cannot finish (the Job died, a backup did not match its recorded sha256, or the bytes did not hash to the SHA-256 the Job sent with them) is cut off before its last bytes, so the browser reports it failed. HEAD is refused, since it would spend the ticket on no body.
|
||
*/
|
||
get: operations["exportDownload"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/jobs": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Latest async world operations (backup, restore, export) for a server (owner-or-admin).
|
||
* @description Backup, restore and export run as cluster Jobs, so a 202 that later failed left its only trace in the Job object. This route projects the newest such Jobs, newest first, so failures are observable without kubectl. State is "running" | "succeeded" | "failed".
|
||
*/
|
||
get: operations["listServerJobs"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List a directory in a server's world volume (owner-or-admin; server must be stopped).
|
||
* @description Lists one directory inside the server's world volume — the repair lever for a server that will not boot because a config file is wrong. The world PVC is RWO and held by a running server, so the server must be fully stopped first (409 not_stopped otherwise). The listing runs as a one-shot Job whose output is read back through pods/log, so the call is synchronous but takes seconds rather than milliseconds. Paths are resolved inside the world root by os.Root, so "..", an absolute path, and a symlink leaving the root are all refused with 400 bad_path. Listings are capped; truncated reports that the cap was hit.
|
||
*/
|
||
get: operations["listServerFiles"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/file": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Read a file from a server's world volume (owner-or-admin).
|
||
* @description Returns one file's bytes, base64-encoded, from inside the server's world volume. Same stopped-gate and os.Root containment as the directory listing, except staff may read login/lobby's felis-experience.json while running. Reads are capped at 1 MiB; a larger file is 413 rather than a truncated read, because a config editor that silently returned half a file would let a subsequent save destroy the other half.
|
||
*/
|
||
get: operations["readServerFile"];
|
||
/**
|
||
* Write a file in a server's world volume (owner-or-admin).
|
||
* @description Replaces a file's contents, creating the file if absent but never creating its parent directories. Content is base64 so arbitrary bytes (CRLF endings, a BOM) survive intact. Writes are capped at 256 KiB — the Job spec carries the content, and etcd bounds the object — so a larger body is 413. Same stopped-gate and os.Root containment as the read; a write through a symlink leaving the world root is refused. The replacement is atomic (a synced temporary sibling renamed over the file, keeping its mode), so a failed write leaves the old file whole. With expect_sha256 the write lands only if the file still has that hash; otherwise 409 file_changed. content_sha256 is the SHA-256 of the content: content that hashes otherwise changed on the way and is refused (400 digest_mismatch) before a Job starts, and the Job checks the bytes it received the same way before writing. Staff may save login/lobby's startup-only felis-experience.json while running; restart to apply. That config cannot be a symlink. Audited as file.write.
|
||
*/
|
||
put: operations["writeServerFile"];
|
||
post?: never;
|
||
/**
|
||
* Delete a file or folder in a server's world volume (owner-or-admin; server must be stopped).
|
||
* @description Deletes a file, a symlink (never what it points at) or a folder with everything in it. The world root itself is refused (400 bad_path). Same stopped-gate, world lock and os.Root containment as a write. The panel confirms first; this route does not. Audited as file.delete.
|
||
*/
|
||
delete: operations["deleteServerFile"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files/mkdir": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Make a folder in a server's world volume (owner-or-admin; server must be stopped).
|
||
* @description Makes one folder. Its parent must already exist (404), and nothing may be at the path yet (409 file_exists). Same stopped-gate, world lock and os.Root containment as a write. Audited as file.mkdir.
|
||
*/
|
||
post: operations["makeServerFolder"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files/rename": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Move or rename a file or folder in a server's world volume (owner-or-admin; server must be stopped).
|
||
* @description Moves the file or folder at path to to. It never replaces: an existing destination is 409 file_exists, and a missing destination folder is 404. server.properties, config/paper-global.yml and config/ cannot be moved under any name they are reached by (400 bad_path), because elsewhere the read path would no longer withhold their secrets. Same stopped-gate, world lock and os.Root containment as a write. Audited as file.rename.
|
||
*/
|
||
post: operations["renameServerFile"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files/download": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Start downloading one file or folder of a stopped server's world (owner-or-admin).
|
||
* @description An export (poll GET /exports/{ticket}, then open its download): a Job reads the file, or zips the folder, from the world volume read-only and hands it to felis-api, which streams it to the browser. A file saves under its own name with its length; a folder as NAME.zip, streamed without one, with symbolic links, devices and sockets left out. config/paper-global.yml, the cluster's forwarding secret, is refused as a file and left out of a folder, and server.properties goes out with its rcon.password and forwarding-secrets redacted; both are matched by the file itself, so a link to either under another name is guarded too. The server cannot start until the download has ended. Two file downloads per user at a time, 4 across the install, 30 per user per hour, counted apart from world and backup exports. Audited as file.download.
|
||
*/
|
||
post: operations["downloadServerFile"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files/upload": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
/**
|
||
* Upload a file into a server's world volume (owner-or-admin; server must be stopped).
|
||
* @description Lands the raw request body as the file at path, up to 64 MiB — a plugin jar, a datapack, a world region; a bigger file goes up as an upload session (POST …/files/uploads). Content-Length is required (411 length_required). An existing file is 409 file_exists unless overwrite=true; a folder at the path is 400 bad_path either way. The body is staged on felis-api's disk first and then fetched by the file Job with a one-time token, so the world lock is taken only after the body has arrived and a slow upload holds off no backup. The file lands atomically: a synced temporary sibling is checked against the staged size and SHA-256, then renamed into place, so a failed upload leaves the old file whole. The body carries its SHA-256 as Content-Digest; felis-api checks it as the body arrives, and the Job checks the same digest again as it fetches the staged copy, so every hop between the browser and the world volume is verified. Same stopped-gate and os.Root containment as a write. Audited as file.upload.
|
||
*/
|
||
put: operations["uploadServerFile"];
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files/uploads": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Begin an upload session for a file too big for one request (owner-or-admin; server must be stopped).
|
||
* @description A file of any size goes up in parts: this begins a session for path and the file's size, PUT …/uploads/{id}?offset= sends each part (at most part_max_bytes, 32 MiB, so each fits the edge's body limit), and POST …/uploads/{id}/commit lands it. There is no size ceiling but felis-api's staging disk, and room for the whole file is reserved here, so an upload that begins is one the disk can finish (507 upload_staging_full otherwise). A session belongs to the account and server it was begun for, answers no one else, and is dropped after 6 hours untouched. Four sessions per account at a time. Sessions do not survive a felis-api restart.
|
||
*/
|
||
post: operations["beginServerFileUpload"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files/uploads/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Where an upload session stands (owner-or-admin, the account that began it).
|
||
* @description received is where the next part starts: after a lost answer or a 409 upload_offset_mismatch, read it here and continue from there. Needs no stopped server.
|
||
*/
|
||
get: operations["getServerFileUpload"];
|
||
/**
|
||
* Send one part of an upload session (owner-or-admin, the account that began it).
|
||
* @description The raw body is appended at offset, which must be where the session ends. Content-Length and the part's own Content-Digest are required, and the part is taken whole or not at all: one cut short, or one whose bytes do not hash to its digest, leaves the session where it was. Parts go one at a time (409 upload_busy while one arrives). Needs no stopped server, so starting the server midway costs only the commit's refusal until it is stopped again.
|
||
*/
|
||
put: operations["putServerFileUploadPart"];
|
||
post?: never;
|
||
/** Cancel an upload session and free its room (owner-or-admin, the account that began it). */
|
||
delete: operations["deleteServerFileUpload"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files/uploads/{id}/commit": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Land a finished upload session in the world volume (owner-or-admin; server must be stopped).
|
||
* @description Starts the Job that fetches the session's bytes from felis-api and lands them at its path, checked against their size and SHA-256 and renamed into place, so a failed landing leaves the old file whole. It answers at once with the op; GET …/files/ops reports how it ends (file_exists when a file is at the path and overwrite is not true). The Job holds the world volume while it runs, so the server cannot start meanwhile. A Job that fails before it has every byte leaves the session to commit again; once the bytes have gone to the Job the session is gone. Audited as file.upload.
|
||
*/
|
||
post: operations["commitServerFileUpload"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files/unzip": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Extract a .zip into the folder holding it (owner-or-admin; server must be stopped).
|
||
* @description Starts a Job that extracts the archive into a temporary folder beside it and moves the result into place, and answers at once with the op; GET …/files/ops reports how it ends. Nothing changes unless every entry is safe: an entry leaving the folder, an absolute path, or a link ends archive_unsafe or archive_symlink; an entry whose size differs from what the archive declares ends archive_invalid; a file where the archive has a folder, or the reverse, ends type_conflict. Without overwrite an archive that would replace any file ends file_exists with the files it would replace, for the caller to confirm and run again with overwrite. Names stored in GBK, as Windows zips in a Chinese locale have them, are read as such. The Job holds the world volume while it runs. Audited as file.unzip.
|
||
*/
|
||
post: operations["unzipServerFile"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/files/ops": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* A server's background uploads and extractions (owner-or-admin).
|
||
* @description Newest first: the one running, if any, and those that ended within the last 30 minutes, at most 10. Needs no stopped server.
|
||
*/
|
||
get: operations["listServerFileOps"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/schedules": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** List a server's scheduled tasks (owner-or-admin). */
|
||
get: operations["listServerSchedules"];
|
||
put?: never;
|
||
/**
|
||
* Add a scheduled task to a server (owner-or-admin).
|
||
* @description The task belongs to the server's current owner: once the server has another owner felis-api disables it instead of running it, until somebody saves it again. felis-api checks the tasks every 15 seconds; a run it was down for is started late, up to 10 minutes, and dropped as missed after that. A command runs only on a running server, a restart only restarts a running one, and a start goes through the running-server cap and a pending retirement like a wake. Audited as schedule.create; each run as schedule.run by scheduler.
|
||
*/
|
||
post: operations["createServerSchedule"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/schedules/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
/**
|
||
* Change a scheduled task (owner-or-admin).
|
||
* @description Replaces the task's settings and recomputes its next run. The task passes to the server's current owner. Refused while a run is in progress. Audited as schedule.update.
|
||
*/
|
||
put: operations["updateServerSchedule"];
|
||
post?: never;
|
||
/**
|
||
* Remove a scheduled task (owner-or-admin).
|
||
* @description Refused while a run is in progress. Audited as schedule.delete.
|
||
*/
|
||
delete: operations["deleteServerSchedule"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}/schedules/{id}/run": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Run a scheduled task now (owner-or-admin).
|
||
* @description Starts a run at once, without the players' warning, whether the task is enabled or not; its next scheduled run stays where it was. The answer is the task after the run's first step: a command, stop or start has finished, and a restart or backup goes on in the background (run_state). Audited as schedule.run_now, and the run itself as schedule.run.
|
||
*/
|
||
post: operations["runServerSchedule"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/users": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List users (admin only).
|
||
* @description Returns a page of non-deleted users matching optional query filters, newest first. Every route under /users gates on the admin Zero-Trust path.
|
||
*/
|
||
get: operations["listUsers"];
|
||
put?: never;
|
||
/** Create a user (admin only). */
|
||
post: operations["createUser"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/users/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Get user detail (admin only). */
|
||
get: operations["getUser"];
|
||
put?: never;
|
||
post?: never;
|
||
/** Soft-delete a user — releases servers, revokes sessions (admin only, cannot delete self). */
|
||
delete: operations["deleteUser"];
|
||
options?: never;
|
||
head?: never;
|
||
/** Edit a user (admin only, cannot patch self). */
|
||
patch: operations["patchUser"];
|
||
trace?: never;
|
||
};
|
||
"/api/v1/users/{id}/disable": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Disable or re-enable a user (admin only, cannot disable self).
|
||
* @description Disabling a user additionally revokes every live session so the lockout is immediate. Re-enabling simply clears the flag.
|
||
*/
|
||
post: operations["disableUser"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/users/{id}/quotas": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Get a user's quotas (admin only). */
|
||
get: operations["getQuotas"];
|
||
/**
|
||
* Set a user's quotas (admin only).
|
||
* @description Replaces all four caps at once. An absent or null field is unlimited; 0 grants none of that resource, so every claim that needs it is refused. An empty body lifts every cap. A cap below what the user already owns refuses new claims and leaves the servers they have alone.
|
||
*/
|
||
put: operations["setQuotas"];
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/users/{id}/sessions": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** List a user's live sessions (admin only). */
|
||
get: operations["listUserSessions"];
|
||
put?: never;
|
||
post?: never;
|
||
/** Revoke every live session of a user (admin only). */
|
||
delete: operations["revokeUserSessions"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/users/{id}/sessions/{hash}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
post?: never;
|
||
/** Revoke a single session of a user (admin only). */
|
||
delete: operations["revokeUserSession"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/users/{id}/passkeys": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
post?: never;
|
||
/**
|
||
* Unbind every passkey of a user (owner only) — authenticator remediation.
|
||
* @description Severs a compromised or planted authenticator that would otherwise outlive a session revoke. A complete remediation pairs this with revoking the user's sessions (DELETE /users/{id}/sessions/{hash}): unbinding the credential alone leaves the live hijacked session, and revoking sessions alone leaves a re-enrollable credential. It is not a lockout — the account re-enters via the email-OTP door or op-login and re-enrolls. Removing zero passkeys is a 200 no-op, not a 404.
|
||
*/
|
||
delete: operations["unbindUserPasskeys"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/users/{id}/links": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Force-link a Minecraft UUID to a user, bypassing the code-verification flow (admin only).
|
||
* @description The UUID must not already be bound to a different user (409). Same (user, uuid) pair is idempotent (200). When auth_source is omitted it is derived from the UUID's version nibble exactly as on the mint path (v3 → thirdparty, else mojang), so a force-linked thirdparty account keeps its reclaim-guard protection.
|
||
*/
|
||
post: operations["linkAccount"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/users/{id}/links/{mc_uuid}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
post?: never;
|
||
/** Remove a single Minecraft UUID binding from a user (admin only). */
|
||
delete: operations["unlinkAccount"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/link/sources": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** List configured sources for staff game-role designation. */
|
||
get: operations["linkSources"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/link/profile": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Look up a role by name or native UUID in a selected authentication source.
|
||
* @description Staff-only preview; role lookup does not prove account ownership and creates no binding.
|
||
*/
|
||
get: operations["lookupProfile"];
|
||
put?: never;
|
||
/**
|
||
* Designate a role as the authenticated staff account's game identity.
|
||
* @description Requires a fresh login factor. Re-queries the native UUID, maps it on the server, and binds only to the caller. Other users' bindings cannot be overwritten. Panel initialization does not require this operation.
|
||
*/
|
||
post: operations["linkProfile"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/link/start": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Report account-link status and in-game instructions (web side, spec §10). */
|
||
post: operations["linkStart"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/link/verify": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Consume an in-game link code and bind the account. */
|
||
post: operations["linkVerify"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/email/start": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Mint and deliver an email one-time code for the caller (web onboarding, spec §B2).
|
||
* @description Generates a one-time code bound to the authenticated principal and the supplied address, persists only its hash, and delivers it out of band. The code is never returned in the response. A re-request supersedes the prior unconsumed code. Once the account has a passkey or a verified email, the session must have reauthed within 5 minutes (403 reauth_required).
|
||
*/
|
||
post: operations["emailOtpStart"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/email/verify": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Redeem an email one-time code and mark the caller's email verified (spec §B2).
|
||
* @description Consumes a previously delivered code for the authenticated principal. On success the user's email is written and email_verified is set true. When the new address replaces a different verified one, every other session of the caller is signed out: sign-in codes now go to the new address, so a session opened through the old one ends; the old address is mailed a notice with the new one masked. A verified code also counts as a reauth for this session. Too many incorrect attempts lock the code (429 otp_locked); 10 wrong codes in 24h, counted across every code, lock the account's email-code door until the window ends (429 otp_account_locked with Retry-After). An unknown, expired, consumed, or mismatched code is a 400.
|
||
*/
|
||
post: operations["emailOtpVerify"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/email": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Record the caller's email WITHOUT verifying it (setup bootstrap, spec §B2).
|
||
* @description Writes the supplied address to the authenticated principal's user row and clears email_verified (already false for a fresh Owner). The setup bootstrap has no SMTP, so the Owner cannot receive an emailed code; a later Settings/SMTP flow proves control of the address via /account/email/verify. Clearing a verified address strips a factor, so once the account has one the session must have reauthed within 5 minutes (403 reauth_required).
|
||
*/
|
||
post: operations["setEmail"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/passkey/register/begin": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Begin a passkey (WebAuthn) registration ceremony for the caller (spec §14, Phase 6 bind).
|
||
* @description Mints a credential-creation challenge bound to the authenticated principal, stashes the server-side ceremony state under a short TTL, and returns the WebAuthn publicKey creation options for navigator.credentials.create(). The challenge is never echoed by the client. Once the account has a passkey or a verified email, the session must have reauthed within 5 minutes (403 reauth_required). 503 when the WebAuthn verifier is not configured on this instance.
|
||
*/
|
||
post: operations["passkeyRegisterBegin"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/passkey/register/finish": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Finish a passkey registration ceremony and bind the credential (spec §14, Phase 6 bind).
|
||
* @description Consumes the caller's live registration challenge (single-use), verifies the authenticator's attestation against the server-stashed ceremony state, and persists the public credential. A missing or expired ceremony is a 400; an attestation that fails verification is a 400; a credential already bound to any account is a 409. The verified email is mailed a notice, and the ceremony counts as a reauth for this session. 503 when the WebAuthn verifier is not configured.
|
||
*/
|
||
post: operations["passkeyRegisterFinish"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/passkey/credentials": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List the passkeys the caller has bound (spec §14, Phase 6 bind).
|
||
* @description Returns the authenticated principal's own bound passkeys, newest first, as display projections (never the public key). Reading the credential list does not need the WebAuthn verifier, so it succeeds even where begin/finish report 503.
|
||
*/
|
||
get: operations["passkeyList"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/passkey/credentials/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
post?: never;
|
||
/**
|
||
* Unbind one of the caller's passkeys (spec §14, Phase 6 bind).
|
||
* @description Removes a passkey scoped to the authenticated principal, so a caller can only unbind their OWN credential. An unknown or cross-user id is a 404; it never silently no-ops as success. The account's only passkey cannot be removed while its email is unverified (409 last_passkey): it is then the account's only durable way in. Removing a passkey signs out every other session of the caller, so a session opened with that passkey ends with it, and mails the verified email a notice. The session must have reauthed within 5 minutes (403 reauth_required).
|
||
*/
|
||
delete: operations["passkeyDelete"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/reauth": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Say whether a passkey or email change needs a reauth first, and how to give one.
|
||
* @description needed is true when the account has a passkey or a verified email and this session has not proven one within the last 5 minutes. until is when the current proof stops counting. factors lists the ways this caller can reauth, best first: passkey (an enrolled passkey), email (a player's verified address), sign_in (an operator signs out and back in through op-login or a passkey).
|
||
*/
|
||
get: operations["reauthStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/reauth/passkey/begin": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Begin a passkey assertion that reauths this session.
|
||
* @description Returns WebAuthn assertion request options over the caller's own passkeys, bound to a fresh reauth-purpose challenge.
|
||
*/
|
||
post: operations["reauthPasskeyBegin"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/reauth/passkey/finish": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Finish the passkey assertion and mark this session reauthed for 5 minutes.
|
||
* @description Verifies the assertion against the reauth challenge with the login door's user-verification and clone checks (a credential or assertion without user verification, or a cloned authenticator, is 400 passkey_login_invalid).
|
||
*/
|
||
post: operations["reauthPasskeyFinish"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/reauth/email/start": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Mail a reauth code to the caller's verified address.
|
||
* @description For players with a verified email. Operators reauth with a passkey or by signing in again (403 staff_reauth).
|
||
*/
|
||
post: operations["reauthEmailStart"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/reauth/email/verify": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Redeem the reauth code and mark this session reauthed for 5 minutes. */
|
||
post: operations["reauthEmailVerify"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/sessions": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List the caller's own live sessions, marking the one this request came in on.
|
||
* @description Every device signed in to the caller's account, most recently seen first, with the one this request came in on marked current.
|
||
*/
|
||
get: operations["listMySessions"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/sessions/{hash}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
post?: never;
|
||
/**
|
||
* Sign out one of the caller's sessions.
|
||
* @description Scoped to the caller: a hash that is not one of the caller's live sessions is a 404 whoever it belongs to. Revoking the session the request came in on is a sign-out; the cookie is cleared and signed_out is true.
|
||
*/
|
||
delete: operations["revokeMySession"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/sessions/revoke-others": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Sign out every session of the caller except the one making this request. */
|
||
post: operations["revokeMyOtherSessions"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/migrate": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Report the caller's active account-migration and where it is in the flow (spec §B3 inherit, web side).
|
||
* @description Read-only. Returns the live migration whose source is the authenticated principal, if any, so the web onboarding can resume the flow: whether a confirmation step-up is still needed, which factor confirmed it and until when, the named target, and the one-time code's expiry once issued. The step-up counts only for the session that gave it and for 10 minutes, so a confirmation made in another session, one that lapsed, and a code that expired unspent all read as initiated. active:false when the caller has no live migration.
|
||
*/
|
||
get: operations["migrateStatus"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/migrate/confirm/otp/start": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Send a fresh email one-time code to confirm control of the migrating source account (spec §B3 step-up).
|
||
* @description Opens the email-OTP confirmation factor for the caller's initiated migration. This is a FRESH step-up bound to the migrate purpose, never mere session possession. If the account has ANY passkey enrolled, email-OTP is refused with 409 passkey_required — the stronger factor is forced. The code is delivered out of band and never returned; requires a verified email on the account.
|
||
*/
|
||
post: operations["migrateConfirmOtpStart"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/migrate/confirm/otp/verify": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Redeem the email one-time code and confirm the migration (spec §B3 step-up).
|
||
* @description Consumes the fresh migrate-purpose email code for the caller's initiated migration and advances it to confirmed with confirm_factor email_otp. Too many wrong attempts lock the code (429 otp_locked), and 10 wrong codes in 24h lock the account's email-code door (429 otp_account_locked with Retry-After); an unknown, expired, consumed, or mismatched code is a 400 invalid_code.
|
||
*/
|
||
post: operations["migrateConfirmOtpVerify"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/migrate/confirm/passkey/begin": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Begin a fresh passkey assertion to confirm control of the migrating source account (spec §B3 step-up).
|
||
* @description Returns WebAuthn assertion request options for the caller's own enrolled passkeys, bound to a fresh migrate-purpose challenge. This is the forced factor whenever a passkey exists. The finish call proves the assertion and, exactly as the login door does, runs the clone-signal (sign-count) check before confirming.
|
||
*/
|
||
post: operations["migrateConfirmPasskeyBegin"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/migrate/confirm/passkey/finish": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Finish the passkey assertion and confirm the migration (spec §B3 step-up).
|
||
* @description Verifies the WebAuthn assertion against the fresh migrate-purpose challenge and, like the login door, applies the per-credential user-verification check and the authenticator sign-count clone check: either refusal fails closed (400 passkey_login_invalid) and is audited. On success the migration advances to confirmed with confirm_factor passkey.
|
||
*/
|
||
post: operations["migrateConfirmPasskeyFinish"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/migrate/issue-code": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Name the target account and mint the one-time migration code (spec §B3 inherit).
|
||
* @description For a migration confirmed by a step-up in this same session within the last 10 minutes, binds the named target account and mints a single one-time code (only its hash is stored) that the target must redeem while logged in AS that target — an intercepted code is useless to anyone else. The target must exist and be neither disabled nor soft-deleted, and cannot be the source. The source's verified address is sent a notice naming the target and the expiry, and another when the code is redeemed.
|
||
*/
|
||
post: operations["migrateIssueCode"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/account/migrate/redeem": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Redeem a migration code as the named target and inherit the source's owned servers (spec §B3 inherit).
|
||
* @description The authenticated caller — who must be the target named at issue time — spends the one-time code. In a single atomic step the source's owned servers are re-pointed to the caller and the source account is retired (disabled and soft-deleted), which also spends the code so it cannot be replayed. The caller keeps its own in-game identity and credentials; only server ownership moves.
|
||
*/
|
||
post: operations["migrateRedeem"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/me/submissions": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** List the caller's own modpack submissions with each linked build's outcome (user-directed lane over §16). */
|
||
get: operations["mySubmissions"];
|
||
put?: never;
|
||
/** Submit a modpack for admin review (user side; user-directed lane over §16). Starts no build. */
|
||
post: operations["createSubmission"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/me/submissions/limits": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* The per-upload build-context cap
|
||
* @description The effective [registry] context_max_bytes, 1 GiB by default. The panel checks a file against it before upload and sends the file through the chunked upload (/api/v1/me/submissions/{id}/context/upload), so the cap holds behind the Cloudflare edge too, whose proxy refuses a single body over 100 MB.
|
||
*/
|
||
get: operations["submissionLimits"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/me/submissions/{id}/context": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Upload the modpack build context for your own pending submission (user side; user-directed lane over §16).
|
||
* @description The request body IS the raw gzip build context (context.tar.gz) — not JSON, not multipart — streamed to the platform-derived, id-namespaced location Kaniko reads via --context. The submitter is taken from the principal; a submission the caller does not own is reported as 404, so this endpoint cannot upload to or probe another user's submission. Only a pending_review submission accepts a context (409 otherwise), and one withdrawn or deleted while its context streams in answers 404 with the bytes discarded; a wrong-format or oversize body is rejected with 400 (the per-upload cap is [registry] context_max_bytes, 1 GiB by default; GET /api/v1/me/submissions/limits reports it so a client can check a file before sending it). This request carries the whole context, so behind the Cloudflare edge, whose proxy refuses bodies over 100 MB with its own HTML 413 before they reach the API, a larger context goes through the chunked upload at /api/v1/me/submissions/{id}/context/upload instead. An upload that would push the caller past their per-user stored-context budget is refused with 403 before the excess is persisted. The body's SHA-256 is required as Content-Digest; bytes that do not hash to it were changed on the way, and none of them replace the context stored before. Returns 503 when the deployment's context store has no implemented upload transport.
|
||
*/
|
||
post: operations["uploadSubmissionContext"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/me/submissions/{id}/context/upload": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Where your chunked context upload stands (the resume point).
|
||
* @description The chunked form of POST /api/v1/me/submissions/{id}/context, for a context larger than one request carries through the edge. received is how many bytes are staged: the next part starts there. A client reads it before the first part and again after a failed one. Nothing staged reads as 0. Same owner scoping as the single upload (404 for another user's submission, 409 once reviewed).
|
||
*/
|
||
get: operations["getContextUpload"];
|
||
/**
|
||
* Append one part of your chunked context upload.
|
||
* @description The body is the part's raw bytes, at most part_max_bytes (32 MiB). offset is where they start: 0 starts the upload over, and anything else must equal the staged length, or the answer is 409 upload_offset_mismatch and the client reads GET for where to resume. The first part must open with the gzip magic (400). The staged total meets the same context cap (400) and storage budget (403) as a single upload. A part that breaks off is cut back off, and so is one whose bytes do not hash to its Content-Digest, so the staged bytes are always a prefix of the file. One request per upload at a time (409 upload_busy). Staged bytes untouched for 24 hours are deleted. The budget check reads blob sizes remembered for up to a minute; when a size has to be read and the uploads store does not answer, the answer is 503 uploads_store_unavailable with Retry-After, and the same part can be sent again.
|
||
*/
|
||
put: operations["putContextUploadPart"];
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/me/submissions/{id}/context/upload/complete": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/**
|
||
* Store your staged chunked upload as the submission's build context.
|
||
* @description Runs every check of POST /api/v1/me/submissions/{id}/context on the staged bytes (format, cap, budget, room), records the digest the same way, and deletes the staged copy. Holds the same per-user upload cooldown (429) and writes the same submission.upload audit event. Nothing staged is 400. After a failure the staged bytes stay, for a retry. The budget is checked against every blob's size read from the uploads store; a store that does not answer is 503 uploads_store_unavailable with Retry-After.
|
||
*/
|
||
post: operations["completeContextUpload"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/me/submissions/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
post?: never;
|
||
/**
|
||
* Withdraw your own pending submission (user side; user-directed lane over §16).
|
||
* @description Retracts the caller's own submission while it is still pending review: the row and its uploaded build context are deleted, freeing the pending slot and the per-user storage budget for a fresh submission. A reviewed submission is frozen (409 — its build may already be consuming the context), and a submission the caller does not own reads back as 404, so this endpoint cannot probe or clear another user's uploads.
|
||
*/
|
||
delete: operations["withdrawSubmission"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/servers/{name}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
/** Mutate a server spec (admin). Storage is immutable. */
|
||
patch: operations["patchServer"];
|
||
trace?: never;
|
||
};
|
||
"/api/v1/images/build": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* List builds (admin), newest first.
|
||
* @description One page of the build history across every admin. Rows are read as stored (the reconcile loop advances them; GET /images/build/{id} reconciles one on demand) and leave out the Dockerfile, which GET /images/build/{id} returns.
|
||
*/
|
||
get: operations["listBuilds"];
|
||
put?: never;
|
||
/** Submit an image build (admin). A build is build-time RCE against the cluster. */
|
||
post: operations["buildImage"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/images/build/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Get one build's status (admin). */
|
||
get: operations["getBuild"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/images/build/{id}/logs": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Stream a build's Job log over SSE (admin, spec §16 / §416). */
|
||
get: operations["buildLogs"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/images/build/{id}/cancel": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Cancel a running build (admin). */
|
||
post: operations["cancelBuild"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/images/build/{id}/scan": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** The scan gate's verdict and findings for a build (admin). */
|
||
get: operations["getBuildScan"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/images/build/{id}/scan/report": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Download a build's full Trivy JSON report (admin). */
|
||
get: operations["getBuildScanReport"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/images/build/{id}/sbom": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** Download a build's CycloneDX SBOM (admin). */
|
||
get: operations["getBuildSBOM"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/images": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** List whitelisted images (admin). */
|
||
get: operations["listImages"];
|
||
put?: never;
|
||
/** Whitelist an externally-built image by reference (admin). */
|
||
post: operations["addImage"];
|
||
/** Remove an image from the whitelist by reference (admin). */
|
||
delete: operations["removeImage"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/submissions": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** The admin review queue — every user's modpack submissions (admin; user-directed lane over §16). */
|
||
get: operations["listSubmissions"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/submissions/{id}/approve": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Approve a submission and start its Trivy-gated build (admin; user-directed lane over §16). Approval is layered in front of the scan, never instead of it. */
|
||
post: operations["approveSubmission"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/submissions/{id}/context": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/**
|
||
* Download a submission's uploaded build context (admin; user-directed lane over §16).
|
||
* @description The reviewer's read path to the artifact they are about to approve: the executed Dockerfile lives inside this tarball (Kaniko runs the context's root `Dockerfile`), so without it the human gate would be blind. Streams the stored context.tar.gz verbatim with an attachment disposition — the same bytes the build Pod fetches over the internal face. 404 when the submission is unknown or has no uploaded context; 503 when the deployment's context store has no implemented transport.
|
||
*/
|
||
get: operations["downloadSubmissionContext"];
|
||
put?: never;
|
||
post?: never;
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/submissions/{id}/reject": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
/** Reject a submission with a required reason (admin; user-directed lane over §16). Starts no build. */
|
||
post: operations["rejectSubmission"];
|
||
delete?: never;
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
"/api/v1/submissions/{id}": {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
get?: never;
|
||
put?: never;
|
||
post?: never;
|
||
/**
|
||
* Retire a submission outright — row and uploaded context (admin; user-directed lane over §16).
|
||
* @description Removes the submission and its uploaded build context, any status — the lane's only lifecycle valve, and the path that reclaims a rejected or consumed upload from the uploads PVC. The reviewer identity is recorded in the audit event, not on the (now deleted) row. Deleting an approved submission whose build is still running fails that build's context fetch; the admin has explicitly chosen to retire the artifact.
|
||
*/
|
||
delete: operations["deleteSubmission"];
|
||
options?: never;
|
||
head?: never;
|
||
patch?: never;
|
||
trace?: never;
|
||
};
|
||
}
|
||
export type webhooks = Record<string, never>;
|
||
export interface components {
|
||
schemas: {
|
||
AuthSourceConfig: {
|
||
/** @description Permanent UUID namespace; saved tags cannot be renamed or removed. mojang is reserved. */
|
||
tag: string;
|
||
/** @description Unique case-insensitive display prefix. */
|
||
prefix: string;
|
||
/** @description hasJoined endpoint; HTTPS required except for localhost or private literal IP addresses. No query or fragment. */
|
||
url: string;
|
||
/** @description Optional Yggdrasil API base for role lookup; empty infers it from the standard hasJoined suffix. */
|
||
api_url: string;
|
||
enabled: boolean;
|
||
};
|
||
StartupStatus: {
|
||
/** @enum {string} */
|
||
stage: "creating" | "scheduling" | "preparing" | "booting" | "failed";
|
||
reason?: string;
|
||
message?: string;
|
||
/** Format: date-time */
|
||
startedAt?: string;
|
||
logsAvailable: boolean;
|
||
};
|
||
WakePolicySettings: {
|
||
maxRunningServers: number;
|
||
wakeCooldownSeconds: number;
|
||
revision: string;
|
||
managed: boolean;
|
||
};
|
||
AuthSourcesSettings: {
|
||
/** @description Third-party sources in priority order; built-in Mojang always precedes them and is immutable. */
|
||
sources: components["schemas"]["AuthSourceConfig"][];
|
||
/** @description Opaque revision to send unchanged when saving; stale or concurrent writes return 409. */
|
||
revision: string;
|
||
/** @description True when stored in platform_settings; false while using installation TOML defaults. */
|
||
managed: boolean;
|
||
};
|
||
/** @description Uniform error envelope emitted by every handler (internal/api/errors.go). */
|
||
Error: {
|
||
error: {
|
||
/** @description Stable machine-readable code (e.g. not_found, conflict, forbidden, bad_request). */
|
||
code: string;
|
||
message: string;
|
||
/** @description Correlates the response with server logs (withRequestID middleware). */
|
||
request_id?: string;
|
||
};
|
||
};
|
||
/** @description The SysAdmin-set auto-update maintenance window (internal/api/handlers_updates.go updateWindow). An absolute [start,end) interval during which Felis may apply a Scheduled component's update to itself; both ends null means unset (no apply is ever opened). Keys are always present; their values are null when unset. */
|
||
UpdateWindow: {
|
||
/**
|
||
* Format: date-time
|
||
* @description Window start (RFC3339, inclusive), or null when unset.
|
||
*/
|
||
start: string | null;
|
||
/**
|
||
* Format: date-time
|
||
* @description Window end (RFC3339, exclusive), or null when unset.
|
||
*/
|
||
end: string | null;
|
||
};
|
||
/** @description The newest control-plane database backup the host recorded (internal/api/handlers_dbbackup.go dbBackupView; the record itself is internal/dbbackup Status, written by `felis db backup`). */
|
||
DBBackupStatus: {
|
||
/** @description Null until the first backup has been recorded. */
|
||
last: {
|
||
/**
|
||
* Format: date-time
|
||
* @description When the bundle was written.
|
||
*/
|
||
at: string;
|
||
/** @description Bundle file name, felis-db-<UTC stamp>-<label>.tar. */
|
||
name: string;
|
||
/**
|
||
* @description offsite is the bundle `felis offsite sync` takes after copying world archives; a restore records the newest bundle on disk, which may be one.
|
||
* @enum {string}
|
||
*/
|
||
label: "daily" | "pre-migrate" | "pre-restore" | "offsite" | "manual";
|
||
/** Format: int64 */
|
||
size_bytes: number;
|
||
felis_version?: string;
|
||
/** @description Newest applied migration at backup time. */
|
||
schema_version?: number;
|
||
/** @description Backup directory on the host. */
|
||
dir: string;
|
||
/** @description Why the bundle lacks the MinecraftServer objects (the cluster did not answer the export), when it does. A restore from it brings back the database but no servers. */
|
||
servers_error?: string;
|
||
/**
|
||
* Format: date-time
|
||
* @description When the newest daily bundle (felis-db-backup.timer) in dir was written, as of this record; absent when dir held none. Equal to at when this record is a daily one.
|
||
*/
|
||
daily_at?: string;
|
||
} | null;
|
||
/** @description True when there is no record, no daily bundle, or the newest daily bundle is older than max_age_seconds. A newer manual, pre-migrate or off-site bundle leaves it as it is: the daily timer has still stopped. */
|
||
stale: boolean;
|
||
/**
|
||
* Format: int64
|
||
* @description The freshness limit (26h), shared with `felis db check` and FelisDBBackupStale.
|
||
*/
|
||
max_age_seconds: number;
|
||
};
|
||
/** @description The newest version check the host recorded (internal/api/handlers_updates.go updateReportView; the record is internal/updates StatusReport, written by `felis update --record`, which felis-update-check.timer runs daily). */
|
||
UpdateReport: {
|
||
/** @description Null until the first check has been recorded (internal/updates StatusReport). */
|
||
report: {
|
||
/** Format: date-time */
|
||
checked_at: string;
|
||
/** @description Version of the felis binary that ran the check. */
|
||
felis: string;
|
||
components: components["schemas"]["UpdateComponent"][];
|
||
} | null;
|
||
/** @description True when there is no record or it is older than max_age_seconds. */
|
||
stale: boolean;
|
||
/**
|
||
* Format: int64
|
||
* @description The freshness limit (26h).
|
||
*/
|
||
max_age_seconds: number;
|
||
};
|
||
/** @description One component's line. available has a newer stable release (latest); unknown means the release feed could not be read and unreadable that the installed version could not, both with error; pinned never changes by policy. */
|
||
UpdateComponent: {
|
||
name: string;
|
||
/** @description Installed version; omitted when unreadable. */
|
||
current?: string;
|
||
/** @description The newer stable release; present only when state is available. */
|
||
latest?: string;
|
||
/** @enum {string} */
|
||
state: "current" | "available" | "unknown" | "unreadable" | "pinned";
|
||
/** @description The `felis update --<selector>` flag that prints how to apply it; omitted when none. */
|
||
selector?: string;
|
||
/** @description What the release lookup learned beyond the version; omitted when none. */
|
||
note?: string;
|
||
/** @description Why a version is missing; omitted otherwise. */
|
||
error?: string;
|
||
};
|
||
/** @description Display projection of one bound passkey (internal/api/handlers_passkey.go passkeyCredentialView). Carries no secret — the public key is never returned. */
|
||
PasskeyCredential: {
|
||
/** @description Opaque passkey row id (used to unbind it). */
|
||
id: string;
|
||
/** @description Caller-supplied nickname; empty if none. */
|
||
name: string;
|
||
/** @description Authenticator model id */
|
||
aaguid?: string;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
/**
|
||
* Format: date-time
|
||
* @description Present only once an assertion is verified (deferred login path).
|
||
*/
|
||
last_used_at?: string;
|
||
};
|
||
/**
|
||
* @description MinecraftServer lifecycle phase (internal/apis/felis/v1alpha1).
|
||
* @enum {string}
|
||
*/
|
||
Phase: "Unknown" | "Stopped" | "Starting" | "Running" | "Stopping" | "Failed";
|
||
ExecutionNode: {
|
||
name: string;
|
||
role: string;
|
||
ready: boolean;
|
||
approved: boolean;
|
||
addresses: string[];
|
||
architecture: string;
|
||
};
|
||
WorldMigration: {
|
||
id: string;
|
||
server: string;
|
||
/** @enum {string} */
|
||
state: "backing_up" | "restoring" | "switching" | "succeeded" | "failed";
|
||
stage: string;
|
||
sourceNode: string;
|
||
targetNode: string;
|
||
sourcePVC: string;
|
||
targetPVC: string;
|
||
backup: {
|
||
ref: string;
|
||
/** Format: int64 */
|
||
size: number;
|
||
sha256: string;
|
||
};
|
||
/** Format: date-time */
|
||
started: string;
|
||
/** Format: date-time */
|
||
updated: string;
|
||
switched: boolean;
|
||
attempt: number;
|
||
error?: string;
|
||
};
|
||
NodeControlRequest: {
|
||
/** @enum {string} */
|
||
action: "enable" | "join" | "approve";
|
||
/** @description Stable worker node name; required for join and approve. */
|
||
name?: string;
|
||
/** @description Verified root SSH alias or user@host; required for workers. */
|
||
sshTarget?: string;
|
||
/** @description Fixed node IP; required for enable and join. */
|
||
externalIP?: string;
|
||
/** @description Additional exact /32 or /128 peer addresses. */
|
||
peers?: string[];
|
||
/** @constant */
|
||
confirmMaintenance: true;
|
||
};
|
||
NodeControlTask: {
|
||
id: string;
|
||
request: components["schemas"]["NodeControlRequest"];
|
||
actor: string;
|
||
/** @enum {string} */
|
||
state: "running" | "succeeded" | "failed";
|
||
stage: string;
|
||
/** Format: date-time */
|
||
startedAt: string;
|
||
/** Format: date-time */
|
||
finishedAt?: string;
|
||
error?: string;
|
||
/** @description Most recent 64 KiB of host execution output; absent in task lists. */
|
||
log?: string;
|
||
};
|
||
/** @description Status projection of one server (internal/api/cluster.go ServerInfo). */
|
||
ServerInfo: {
|
||
/** @description Private runtime and startup diagnostics for authorized server managers. */
|
||
startup?: components["schemas"]["StartupStatus"];
|
||
/** @description Execution node; legacy servers report the observed node. */
|
||
nodeName?: string;
|
||
name: string;
|
||
subdomain: string;
|
||
phase: components["schemas"]["Phase"];
|
||
ready: boolean;
|
||
/**
|
||
* @description Present only when set; who may wake the server via domain-autostart.
|
||
* @enum {string}
|
||
*/
|
||
autostartPolicy?: "ownerOnly" | "public" | "allowlist";
|
||
/**
|
||
* @description Present only when set; the operator's target state.
|
||
* @enum {string}
|
||
*/
|
||
desiredState?: "Running" | "Stopped";
|
||
endpointMode?: string;
|
||
endpointAddress?: string;
|
||
/** Format: int32 */
|
||
playersOnline: number;
|
||
/** Format: int32 */
|
||
playersMax: number;
|
||
displayName?: string;
|
||
image?: string;
|
||
/** @description The JVM heap (-Xmx) derived from the memory limit. */
|
||
javaMemory?: string;
|
||
/** @description The pod memory limit (the server's memory as an admin picks it), a Kubernetes quantity such as 4Gi. */
|
||
memory?: string;
|
||
storageSize?: string;
|
||
cpu?: string;
|
||
/**
|
||
* Format: int32
|
||
* @description Seconds the server may sit empty before idle auto-stop scales it down; 0 when it never idles out (off, RCON disabled, or a system server).
|
||
*/
|
||
idleStopSeconds: number;
|
||
/** @description Present and true while the operator cannot read the player count over RCON; idle auto-stop waits until it can. */
|
||
playerCountUnknown?: boolean;
|
||
/** @description Present and true when the CR carries the label felis.lolicon.best/forwarding=legacy. The proxy then forwards this server's players BungeeCord-style in the handshake address instead of modern forwarding (Felis-Legacy Velocity fork only). */
|
||
legacyForwarding?: boolean;
|
||
/**
|
||
* Format: int32
|
||
* @description Present when non-zero; how often the operator recreated the pod of this start after it timed out (at most 3).
|
||
*/
|
||
autoRestarts?: number;
|
||
/** @description Present and true for a Failed server no automatic retry will bring up: its start timed out with the retries spent, or its spec is invalid. A Failed server without it is still in its restart backoff and may come up on its own. */
|
||
startGaveUp?: boolean;
|
||
/** @description Present and true for a system server the reaper never touches; it cannot be given up or deleted. */
|
||
reaperExempt?: boolean;
|
||
/** @description Owner and staff only. Present while the owner has given the server up or an admin is deleting it; the reaper carries that out on its next run. */
|
||
retiring?: components["schemas"]["RetireState"];
|
||
};
|
||
/** @description One row of the fleet-wide admin read (internal/api/handlers_user.go fleetServerView). */
|
||
FleetServer: components["schemas"]["ServerInfo"] & {
|
||
/** @description The owner's display identity (email, or username when the address is absent). Absent for an unclaimed server or when the best-effort owner lookup failed. */
|
||
owner?: string;
|
||
/** @description True when the caller claimed this server, decided by account id so an owner without an email is still recognized. */
|
||
owned: boolean;
|
||
/** @description True for a live, unclaimed, non-system server with no pending deletion, the same rule the claim route enforces. False whenever ownership is unknown. */
|
||
claimable: boolean;
|
||
/** @description Present and true when the owner lookup failed, so an absent owner says nothing about whether the server is claimed. */
|
||
ownerUnknown?: boolean;
|
||
/** @description True for a platform-provisioned system service (the login gate, the lobby). Staff can manage them through the existing server routes; players see them read-only. Creating, claiming and deleting these reserved names remain prohibited. */
|
||
system?: boolean;
|
||
};
|
||
/** @description A pending retirement (internal/api/repo.go RetireState): the owner gave the server up, or with delete an admin is deleting it. The reaper carries it out on its next daily run: it archives the world as a released backup, deletes the world volume and releases the server, and for a deletion also removes it. Until then the server stays stopped and cannot be woken or claimed. */
|
||
RetireState: {
|
||
/** Format: date-time */
|
||
requested_at: string;
|
||
delete: boolean;
|
||
};
|
||
/** @description One player on a server's wake allowlist (internal/api/repo.go AllowlistEntry): someone who joined the server, and so may wake it under autostartPolicy=allowlist unless the owner took that away. */
|
||
AllowlistEntry: {
|
||
/** Format: uuid */
|
||
mc_uuid: string;
|
||
/** @description The live Felis account the UUID is linked to; omitted when there is none (the account was closed or the link removed). */
|
||
username?: string;
|
||
/**
|
||
* Format: date-time
|
||
* @description The player's first join.
|
||
*/
|
||
added_at: string;
|
||
/** @description False once the owner or an admin took the wake right away. */
|
||
can_wake: boolean;
|
||
};
|
||
/** @description One row of the caller's server list (internal/api/repo.go MyServerView). */
|
||
MyServerView: {
|
||
name: string;
|
||
subdomain: string;
|
||
owned: boolean;
|
||
claimable: boolean;
|
||
/** @description Present only when known. */
|
||
phase?: components["schemas"]["Phase"];
|
||
/**
|
||
* Format: int32
|
||
* @description Best-effort from live CRD status; 0 when the cluster is unreachable.
|
||
*/
|
||
playersOnline: number;
|
||
/** Format: int32 */
|
||
playersMax: number;
|
||
/** @description From live CRD status; omitted when unset or the cluster is unreachable. */
|
||
displayName?: string;
|
||
/**
|
||
* @description Owned rows only, from live CRD status.
|
||
* @enum {string}
|
||
*/
|
||
desiredState?: "Running" | "Stopped";
|
||
/**
|
||
* @description Owned rows only, from live CRD status.
|
||
* @enum {string}
|
||
*/
|
||
autostartPolicy?: "ownerOnly" | "public" | "allowlist";
|
||
/** @description Owned rows only. Present and true while the operator cannot read the player count, so a stop may disconnect players. */
|
||
playerCountUnknown?: boolean;
|
||
/**
|
||
* Format: int32
|
||
* @description Owned rows only. How often the operator recreated the pod of this start after it timed out.
|
||
*/
|
||
autoRestarts?: number;
|
||
/** @description Owned rows only. Present and true for a Failed server no automatic retry will bring up; waking it from the panel starts it over. */
|
||
startGaveUp?: boolean;
|
||
/** @description Owned rows only. Present while the server is given up or being deleted. */
|
||
retiring?: components["schemas"]["RetireState"];
|
||
};
|
||
/** @description One scheduled task of a server (internal/api/schedules.go Schedule). It runs at minute_of_day on the weekdays, or with every_minutes set at every multiple of it since midnight on those days, in timezone. */
|
||
Schedule: {
|
||
/** Format: int64 */
|
||
id: number;
|
||
server: string;
|
||
/** @description Free text naming the task; may be empty. */
|
||
label: string;
|
||
/**
|
||
* @description backup of a running server stops it, takes a backup (pruned with the daily restore points, [archive] scheduled_keep) and starts it again; of a stopped server it leaves the server stopped.
|
||
* @enum {string}
|
||
*/
|
||
action: "command" | "restart" | "stop" | "start" | "backup";
|
||
/** @description The console command of a command task */
|
||
command: string;
|
||
/**
|
||
* @description 0 runs once a day at minute_of_day. A restart, stop, start or backup repeats at most every 60 minutes.
|
||
* @enum {integer}
|
||
*/
|
||
every_minutes: 0 | 15 | 30 | 60 | 120 | 180 | 240 | 360 | 480 | 720;
|
||
/** @description Minutes after local midnight; 0 when every_minutes is set. */
|
||
minute_of_day: number;
|
||
/** @description Bitmask of the days it runs on: bit 0 Sunday to bit 6 Saturday. */
|
||
weekdays: number;
|
||
/** @description IANA zone the times are in */
|
||
timezone: string;
|
||
/**
|
||
* @description How long before a restart, stop or backup the players on the server are told (say); 0 for none, and always 0 for a command or start.
|
||
* @enum {integer}
|
||
*/
|
||
warn_minutes: 0 | 1 | 5 | 10 | 15 | 30;
|
||
enabled: boolean;
|
||
/**
|
||
* Format: date-time
|
||
* @description Null while disabled.
|
||
*/
|
||
next_run_at: string | null;
|
||
/**
|
||
* @description What a run in progress is doing; empty when none is.
|
||
* @enum {string}
|
||
*/
|
||
run_state: "" | "claimed" | "stopping" | "backing_up" | "starting";
|
||
/** Format: date-time */
|
||
last_run_at: string | null;
|
||
/**
|
||
* @description How the last run ended; empty before the first and during a run. missed is a run felis-api was down for, dropped once it was 10 minutes late.
|
||
* @enum {string}
|
||
*/
|
||
last_result: "" | "ok" | "skipped" | "failed" | "missed";
|
||
/** @description What happened */
|
||
last_detail: string;
|
||
created_by: string;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
};
|
||
ScheduleInput: {
|
||
label?: string;
|
||
/** @enum {string} */
|
||
action: "command" | "restart" | "stop" | "start" | "backup";
|
||
/** @description Required for a command task and refused for the others. One line; a leading slash is dropped. */
|
||
command?: string;
|
||
/** @enum {integer} */
|
||
every_minutes?: 0 | 15 | 30 | 60 | 120 | 180 | 240 | 360 | 480 | 720;
|
||
minute_of_day?: number;
|
||
weekdays: number;
|
||
timezone: string;
|
||
/** @enum {integer} */
|
||
warn_minutes?: 0 | 1 | 5 | 10 | 15 | 30;
|
||
/** @description Default true. */
|
||
enabled?: boolean;
|
||
};
|
||
/** @description One world backup (internal/api/repo.go BackupView). backup_ref is withheld (spec §286). */
|
||
BackupView: {
|
||
id: string;
|
||
server_name: string;
|
||
/** @description Present only when the world had an owner at backup time. */
|
||
former_owner?: string;
|
||
/** Format: int64 */
|
||
size_bytes: number;
|
||
/** @description inactive_15d (idle reclaim), released (the world of a server its owner gave up or an admin deleted), manual (on demand), pre_restore (the safety snapshot in front of a restore) or scheduled (the daily restore point felis-api takes of a world played since its last one, once the server stops). */
|
||
reason: string;
|
||
status: string;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
/** @description The archive failed a read-back (a checksum, gzip or tar error) and cannot be restored. Omitted when false. */
|
||
corrupt?: boolean;
|
||
/**
|
||
* Format: date-time
|
||
* @description The archive's last read-back that matched. Omitted until the first.
|
||
*/
|
||
verified_at?: string;
|
||
/** @description World entries the archive could not hold (symbolic links, devices, sockets). Omitted when zero. */
|
||
skipped_entries?: number;
|
||
};
|
||
/** @description An export just started (internal/api/exports.go exportTicketView). The ticket opens GET /exports/{ticket} and its download for the user who started it, and nobody else. */
|
||
ExportTicket: {
|
||
/** @description 64 hex characters. */
|
||
ticket: string;
|
||
/** @constant */
|
||
state: "pending";
|
||
/** @description What the download saves as. */
|
||
filename: string;
|
||
};
|
||
/** @description Where an upload session stands (internal/api/handlers_fileops.go fileSessionView). */
|
||
FileUploadSession: {
|
||
/** @description 32 hex characters. */
|
||
id: string;
|
||
/** @description Where the file lands */
|
||
path: string;
|
||
/**
|
||
* Format: int64
|
||
* @description The file's length.
|
||
*/
|
||
size: number;
|
||
/**
|
||
* Format: int64
|
||
* @description Bytes here so far; the next part starts here.
|
||
*/
|
||
received: number;
|
||
/**
|
||
* Format: int64
|
||
* @description The most one part may carry.
|
||
*/
|
||
part_max_bytes: number;
|
||
/** @description The parts taken so far, in order, each with the SHA-256 it arrived with. A client resuming from a file it still holds hashes the same ranges and starts over when one differs. */
|
||
parts: {
|
||
/** Format: int64 */
|
||
size: number;
|
||
sha256: string;
|
||
}[];
|
||
};
|
||
StartFileOp: {
|
||
/** @description Replace files already there. */
|
||
overwrite?: boolean;
|
||
};
|
||
/** @description One background upload or extraction (internal/api/handlers_fileops.go fileOpView). */
|
||
FileOp: {
|
||
id: string;
|
||
/** @enum {string} */
|
||
op: "upload" | "unzip";
|
||
/** @description The file landed */
|
||
path: string;
|
||
/** @enum {string} */
|
||
state: "running" | "succeeded" | "failed";
|
||
/** Format: date-time */
|
||
started_at: string;
|
||
/**
|
||
* Format: date-time
|
||
* @description Omitted while it runs.
|
||
*/
|
||
finished_at?: string;
|
||
/**
|
||
* Format: int64
|
||
* @description Bytes landed or extracted so far; 0 before the first report.
|
||
*/
|
||
done: number;
|
||
/**
|
||
* Format: int64
|
||
* @description Bytes in all; 0 before the first report.
|
||
*/
|
||
total: number;
|
||
/** @description Files an extraction wrote. Omitted otherwise. */
|
||
files?: number;
|
||
/**
|
||
* Format: int64
|
||
* @description Bytes an extraction wrote. Omitted otherwise.
|
||
*/
|
||
bytes?: number;
|
||
error?: components["schemas"]["FileOpError"];
|
||
};
|
||
/** @description Why an op failed (internal/api/handlers_fileops.go fileOpError). code is what the synchronous file routes answer for the same refusal (file_exists, volume_full, file_changed, not_found, bad_path), an extraction's own (archive_invalid, archive_unsafe, archive_symlink, type_conflict), or job_failed for a Job that ended without saying why. */
|
||
FileOpError: {
|
||
code: string;
|
||
message: string;
|
||
/** @description The archive entry refused */
|
||
entry?: string;
|
||
/** @description On file_exists from an extraction, the first 200 files it would replace, sorted. */
|
||
conflicts?: string[];
|
||
/** @description How many files it would replace in all. */
|
||
conflict_count?: number;
|
||
/**
|
||
* Format: int64
|
||
* @description On volume_full
|
||
*/
|
||
need?: number;
|
||
/**
|
||
* Format: int64
|
||
* @description On volume_full
|
||
*/
|
||
avail?: number;
|
||
};
|
||
/** @description Where an export stands (internal/api/exports.go exportStatusView). */
|
||
ExportStatus: {
|
||
/**
|
||
* @description pending while its Job starts; ready once the archive waits for the download, which must begin within 90 seconds; failed when the Job died first.
|
||
* @enum {string}
|
||
*/
|
||
state: "pending" | "ready" | "failed";
|
||
/** @description Why a failed export's Job died. Omitted otherwise. */
|
||
message?: string;
|
||
};
|
||
/** @description One image build (internal/build Build). */
|
||
Build: {
|
||
id: string;
|
||
image_ref: string;
|
||
/** @enum {string} */
|
||
status: "pending" | "building" | "succeeded" | "failed" | "cancelled";
|
||
dockerfile?: string;
|
||
context_ref?: string;
|
||
/** @description Lowercase hex sha256 of the context tarball the build was pinned to (the audit record). Omitted when the request named none. */
|
||
context_digest?: string;
|
||
base_image?: string;
|
||
requested_by: string;
|
||
job_name?: string;
|
||
log_ref?: string;
|
||
error?: string;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
/**
|
||
* Format: date-time
|
||
* @description Omitted until the build reaches a terminal status.
|
||
*/
|
||
finished_at?: string;
|
||
};
|
||
/** @description What a build's scan gate kept (GET /api/v1/images/build/{id}/scan): its verdict under the policy it ran with, the listed findings, and which full documents can be downloaded. */
|
||
BuildScan: {
|
||
build_id: string;
|
||
/** Format: date-time */
|
||
scanned_at: string;
|
||
summary: components["schemas"]["ScanSummary"];
|
||
/** @description The full Trivy JSON report is kept (GET .../scan/report). */
|
||
has_report: boolean;
|
||
/** @description The CycloneDX SBOM is kept (GET .../sbom). */
|
||
has_sbom: boolean;
|
||
};
|
||
/** @description The verdict scan-gate reached on one Trivy report (internal/build ScanSummary). */
|
||
ScanSummary: {
|
||
policy: components["schemas"]["ScanPolicy"];
|
||
/** @description A finding blocked the image, so it was never pushed. */
|
||
blocked: boolean;
|
||
/** @description Packages Trivy found in the image. */
|
||
packages: number;
|
||
/** @description Every finding by severity (CRITICAL, HIGH, MEDIUM, LOW, UNKNOWN); a severity with none is absent. */
|
||
counts: {
|
||
[key: string]: number;
|
||
};
|
||
/** @description The findings the policy blocks on, by severity. */
|
||
blocking_counts: {
|
||
[key: string]: number;
|
||
};
|
||
/** @description Blocking findings first, then the rest, most severe first; at most 100. The downloadable report lists all of them. */
|
||
findings: components["schemas"]["ScanFinding"][];
|
||
/** @description Documents (report, sbom) too large to keep with the build. Omitted when none. */
|
||
omitted?: ("report" | "sbom")[];
|
||
};
|
||
/** @description Which findings block an image ([registry] scan_fail_on / scan_fail_unfixed / scan_accept). */
|
||
ScanPolicy: {
|
||
fail_on: ("CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "UNKNOWN")[];
|
||
/** @description A vulnerability with no fixed release blocks too. */
|
||
fail_unfixed: boolean;
|
||
/** @description Vulnerability ids and secret rule ids accepted as known risks; findings under them never block. Omitted when none. */
|
||
accept?: string[];
|
||
};
|
||
/** @description One vulnerability or leaked secret (internal/build ScanFinding). */
|
||
ScanFinding: {
|
||
/** @description The CVE/GHSA id, or the secret rule id. */
|
||
id: string;
|
||
/** @enum {string} */
|
||
kind: "vulnerability" | "secret";
|
||
/** @enum {string} */
|
||
severity: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "UNKNOWN";
|
||
package?: string;
|
||
installed?: string;
|
||
/** @description The first release that fixes it. Omitted when none exists. */
|
||
fixed?: string;
|
||
/** @description The file or layer Trivy found it in. */
|
||
target: string;
|
||
title?: string;
|
||
blocking: boolean;
|
||
/** @description The policy accepts this id, so it never blocks. Omitted when false. */
|
||
accepted?: boolean;
|
||
};
|
||
/** @description One whitelisted image (internal/build Image). */
|
||
Image: {
|
||
image_ref: string;
|
||
source: string;
|
||
build_id?: string;
|
||
added_by: string;
|
||
enabled: boolean;
|
||
/** Format: date-time */
|
||
added_at: string;
|
||
};
|
||
ContextUploadProgress: {
|
||
/**
|
||
* Format: int64
|
||
* @description Bytes staged so far; the next part starts here.
|
||
*/
|
||
received: number;
|
||
/**
|
||
* Format: int64
|
||
* @description The most one part may carry.
|
||
*/
|
||
part_max_bytes: number;
|
||
/**
|
||
* Format: int64
|
||
* @description The most the whole context may reach ([registry] context_max_bytes).
|
||
*/
|
||
max_context_bytes: number;
|
||
};
|
||
/** @description One user-submitted modpack in the approval lane (internal/submit Submission — a user-directed extension over the §16 build subsystem). The user supplies only display_name; submitted_by comes from the principal and context_ref/image_ref/build_id/reviewed_by are platform-controlled, never client input. */
|
||
Submission: {
|
||
id: string;
|
||
submitted_by: string;
|
||
display_name: string;
|
||
/** @description Platform-derived pinned build context; not user-supplied. */
|
||
context_ref: string;
|
||
/** @description Lowercase hex sha256 of the uploaded context tarball; omitted until one is uploaded. Approval must name it. */
|
||
context_sha256?: string;
|
||
/** @enum {string} */
|
||
status: "pending_review" | "approved" | "rejected";
|
||
/** @description Platform-derived push target, set at approval. */
|
||
image_ref?: string;
|
||
/** @description image_builds.id, set only after the build hand-off succeeds. */
|
||
build_id?: string;
|
||
/**
|
||
* @description The linked build's outcome, attached by the LIST routes (/me/submissions, /submissions) — for a submitter this is the only visible outlet for a failed build. Omitted until a build is linked and its row is readable.
|
||
* @enum {string}
|
||
*/
|
||
build_status?: "pending" | "building" | "succeeded" | "failed" | "cancelled";
|
||
/** @description The build's recorded failure text (e.g. a CRITICAL CVE scan failure), attached alongside build_status. */
|
||
build_error?: string;
|
||
reviewed_by?: string;
|
||
reject_reason?: string;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
/**
|
||
* Format: date-time
|
||
* @description Omitted until an admin approves or rejects.
|
||
*/
|
||
reviewed_at?: string;
|
||
};
|
||
/** @description One row of the admin user list (internal/api/repo.go UserView). */
|
||
UserView: {
|
||
id: string;
|
||
username: string;
|
||
email?: string;
|
||
/** @enum {string} */
|
||
role: "owner" | "admin" | "user";
|
||
disabled: boolean;
|
||
email_verified: boolean;
|
||
server_count: number;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
/** Format: date-time */
|
||
updated_at: string;
|
||
};
|
||
/** @description Full admin view of one user (internal/api/repo.go UserDetail). */
|
||
UserDetail: {
|
||
id: string;
|
||
username: string;
|
||
email?: string;
|
||
/** @enum {string} */
|
||
role: "owner" | "admin" | "user";
|
||
disabled: boolean;
|
||
email_verified: boolean;
|
||
server_count: number;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
/** Format: date-time */
|
||
updated_at: string;
|
||
/**
|
||
* Format: date-time
|
||
* @description Present only when soft-deleted.
|
||
*/
|
||
deleted_at?: string;
|
||
/** @description Omitted when the user has no linked Minecraft account. */
|
||
linked_accounts?: {
|
||
/** Format: uuid */
|
||
mc_uuid: string;
|
||
auth_source: string;
|
||
/** Format: date-time */
|
||
verified_at: string;
|
||
}[];
|
||
};
|
||
/** @description A user's quotas row (internal/api/repo.go QuotaView). An absent or null field is unlimited; 0 grants none of that resource. */
|
||
QuotaView: {
|
||
user_id: string;
|
||
max_servers?: number | null;
|
||
max_cpu_milli?: number | null;
|
||
max_memory_mb?: number | null;
|
||
max_storage_gb?: number | null;
|
||
};
|
||
/** @description One live session, as the account holder and an admin see it (internal/api/repo.go SessionView). */
|
||
SessionView: {
|
||
/** @description The sha-256 of the session cookie; the id the revoke routes take. */
|
||
token_hash: string;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
/**
|
||
* Format: date-time
|
||
* @description When the session last authenticated a request, recorded at most once a minute. A staff session idle for 30 minutes stops authenticating and leaves the list.
|
||
*/
|
||
last_seen_at: string;
|
||
/** @description The browser's User-Agent at sign-in (at most 256 bytes; empty when none was sent). */
|
||
user_agent: string;
|
||
/** @description The address the sign-in came from (empty when unknown). */
|
||
client_ip: string;
|
||
/**
|
||
* Format: date-time
|
||
* @description Present only once the session is revoked.
|
||
*/
|
||
revoked_at?: string;
|
||
/** @description On the holder's own list only, true on the session the request came in on. Absent otherwise. */
|
||
current?: boolean;
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Success, no body. */
|
||
NoContent: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description An unexpected failure (internal); the details are in the server log under the request id. */
|
||
InternalError: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A genuine service token for a caller this operation does not serve (wrong_caller). */
|
||
WrongCaller: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A session of a player (not admin or owner) on the operator console host, refused before any handler (forbidden). */
|
||
StaffOnlyHost: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The session belongs to an account still in first-run setup, which may use only the x-felis-setup-allowed operations until it has a durable sign-in (setup_required). */
|
||
SetupRequired: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The JSON body is over 1 MiB (too_large). */
|
||
TooLarge: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A body sent with a Content-Type other than application/json (unsupported_media_type). */
|
||
UnsupportedMediaType: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The store this writes to is full — the backup archive (backup_store_full), the world volume (volume_full) or the upload area (uploads_full). */
|
||
InsufficientStorage: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Malformed or invalid request (validation, bad body, unknown field). */
|
||
BadRequest: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Authentication missing or invalid. */
|
||
Unauthorized: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Authenticated but not permitted (ownership / admin / quota). */
|
||
Forbidden: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description No such server / build / record. */
|
||
NotFound: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Precondition failed (lost race, not running, already claimed/linked, not stopped). */
|
||
Conflict: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A required prior step is missing (e.g. account not linked). */
|
||
PreconditionFailed: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A required subsystem (builder / console / logs / restorer / repo / cluster) is not wired or reachable. */
|
||
ServiceUnavailable: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description This session is reauthed until the returned time. */
|
||
Reauthed: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
ok: true;
|
||
/** Format: date-time */
|
||
until: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description reauth_required: this change adds, removes or moves a way into the account, and the account has a passkey or a verified email, so the session must have proven one of them within the last 5 minutes. Signing in by passkey, email code, op-login or the setup token counts; a bind-code sign-in does not. GET /api/v1/account/reauth lists the factors that can give the proof, then retry the change. */
|
||
ReauthRequired: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The configured SMTP relay refused the message (code mail_undeliverable), so no code was delivered. Distinct from 500 because the fault is in the install's [smtp] settings, not in the request or the platform — most often a From address the relay will not let this account send as. The relay's own text is deliberately withheld (it names the SMTP account) and written to the felis-api log instead, keyed by the same request_id this response carries. Retrying the same address changes nothing until an operator fixes the relay. */
|
||
MailUndeliverable: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description This install has no [smtp] relay (code mail_unavailable), so no code was minted or sent. The public doors answer it before resolving the address, so it is the same for every address. Sign in with a passkey, or have the operator configure email with felis setup. */
|
||
MailUnavailable: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description This client address called the public sign-in doors faster than the per-address limit allows (code rate_limited); Retry-After gives the seconds until the next call is admitted. The address is the visitor header the install's edge writes ([auth] client_ip_header: CF-Connecting-IP behind the Cloudflare tunnel), else the TCP peer; IPv6 clients share one limit per /64. */
|
||
RateLimited: {
|
||
headers: {
|
||
"Retry-After"?: number;
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The structured access mutation succeeded; the raw RCON reply is in output. */
|
||
AccessResult: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
action: string;
|
||
player?: string;
|
||
node?: string;
|
||
group?: string;
|
||
output: string;
|
||
};
|
||
};
|
||
};
|
||
};
|
||
parameters: never;
|
||
requestBodies: never;
|
||
headers: never;
|
||
pathItems: never;
|
||
}
|
||
export type $defs = Record<string, never>;
|
||
export interface operations {
|
||
executionNodes: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Accepted operation or current state. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
nodes: components["schemas"]["ExecutionNode"][];
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
latestWorldMigrationStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Accepted operation or current state. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["WorldMigration"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
startWorldMigration: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
targetNode: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Accepted operation or current state. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["WorldMigration"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
worldMigrationStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Accepted operation or current state. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["WorldMigration"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
retryWorldMigration: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Accepted operation or current state. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["WorldMigration"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
healthz: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Always ok when the process is up. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
status: "ok";
|
||
};
|
||
};
|
||
};
|
||
};
|
||
};
|
||
readyz: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Repo and Cluster are wired. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
status: "ready";
|
||
};
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
metrics: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Prometheus text exposition format. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"text/plain": string;
|
||
};
|
||
};
|
||
};
|
||
};
|
||
hasJoined: {
|
||
parameters: {
|
||
query: {
|
||
username: string;
|
||
serverId: string;
|
||
ip?: string;
|
||
};
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description A source validated the session; the canonical game profile. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @description Canonical UUID */
|
||
id: string;
|
||
/** @description The name the source returned. A third-party player whose name is registered to a Mojang account gets it back as PREFIX_name, cut to 16 characters. */
|
||
name: string;
|
||
properties?: Record<string, never>[];
|
||
};
|
||
};
|
||
};
|
||
/** @description Not admitted, with no source asked when username or serverId is missing or a parameter is over 64 bytes. Otherwise no source validated the session, the canonical UUID is barred, a third-party source returned a name that is not a legal Minecraft username, or the identity source returned an unparseable id. */
|
||
204: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description The request declared a body. No body is sent back, and the connection is closed. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description The bar-list lookup failed, so the login is not admitted. */
|
||
500: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description No source validated the session and at least one source failed (transport error, redirect, unexpected status, or a 200 without a usable profile). Its player may be the one logging in, so this is not answered as a 204. No body. */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
};
|
||
};
|
||
listServers: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Every server's status projection. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
servers: components["schemas"]["ServerInfo"][];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
createServer: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description Required approved worker in distributed mode; administrator only. */
|
||
nodeName?: string;
|
||
name: string;
|
||
subdomain: string;
|
||
/** @description Trimmed; at most 64 characters, all visible ones or spaces (400 bad_display_name otherwise). */
|
||
displayName?: string;
|
||
image?: string;
|
||
memory?: string;
|
||
storage?: string;
|
||
autostartPolicy?: string;
|
||
resources?: {
|
||
cpu?: string;
|
||
cpuRequest?: string;
|
||
memory?: string;
|
||
memoryRequest?: string;
|
||
};
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Created; starts Stopped. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
subdomain: string;
|
||
/** @constant */
|
||
desiredState: "Stopped";
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
serverReadyCallback: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
204: components["responses"]["NoContent"];
|
||
401: components["responses"]["Unauthorized"];
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
internalSubmissionContext: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The stored gzip tarball, verbatim. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/gzip": string;
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
404: components["responses"]["NotFound"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
internalFileUpload: {
|
||
parameters: {
|
||
query?: never;
|
||
header: {
|
||
/** @description Bearer followed by the token minted with the upload. */
|
||
Authorization: string;
|
||
};
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The staged bytes, verbatim, with their Content-Length. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/octet-stream": string;
|
||
};
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
internalFileUploadLanded: {
|
||
parameters: {
|
||
query?: never;
|
||
header: {
|
||
/** @description Bearer followed by the token the Job fetched the upload with. */
|
||
Authorization: string;
|
||
};
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
204: components["responses"]["NoContent"];
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
internalFileBrowser: {
|
||
parameters: {
|
||
query?: never;
|
||
header: {
|
||
Authorization: string;
|
||
};
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
id?: string;
|
||
result?: Record<string, never>;
|
||
error?: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The next authorized read command. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
id: string;
|
||
/** @enum {string} */
|
||
op: "list" | "read";
|
||
path: string;
|
||
};
|
||
};
|
||
};
|
||
204: components["responses"]["NoContent"];
|
||
400: components["responses"]["BadRequest"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
internalExportUpload: {
|
||
parameters: {
|
||
query?: never;
|
||
header: {
|
||
/** @description Bearer followed by the token minted with the export. */
|
||
Authorization: string;
|
||
/** @description The body's length in bytes, when the Job knows it; the download then carries it as Content-Length. */
|
||
"X-Felis-Export-Length"?: number;
|
||
};
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/gzip": string;
|
||
};
|
||
};
|
||
responses: {
|
||
204: components["responses"]["NoContent"];
|
||
/** @description X-Felis-Export-Length is not a byte count (bad_request); the token is not spent. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
/** @description The backup did not match the sha256 recorded when it was written, and the download was aborted (backup_corrupt). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Nobody opened the download within 90 seconds, the browser left before the archive ended, or what arrived did not number or hash as the Job declared, so the download was cut off (export_expired). */
|
||
410: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
joinEvent: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
mc_uuid: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
204: components["responses"]["NoContent"];
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
internalWake: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
mc_uuid: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Wake accepted (or already awake). */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
desiredState: "Running";
|
||
phase: components["schemas"]["Phase"];
|
||
ready: boolean;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Nothing was started. maintenance_in_progress: a restore, backup or file write holds the server's world volume. start_failed: the last start failed and its automatic retries are spent (ServerInfo.startGaveUp); the server stays down until a person starts it from the panel. server_retiring: the owner gave the server up or an admin is deleting it; it stays down until the reaper archives it. world_reclaiming: the idle reaper is archiving the world; afterwards the server is released with an empty world. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Wake cooldown is still active for this server. */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The node is at its running-server cap (at_capacity). */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
internalStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The server's status projection. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["ServerInfo"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
internalClaim: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
mc_uuid: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Claimed. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
claimed: true;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
412: components["responses"]["PreconditionFailed"];
|
||
};
|
||
};
|
||
internalMenuStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Menu projection for the lobby UI. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
phase: components["schemas"]["Phase"];
|
||
ready: boolean;
|
||
/** Format: int32 */
|
||
playersOnline: number;
|
||
/** Format: int32 */
|
||
playersMax: number;
|
||
claimable: boolean;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
internalMenuAccess: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
mc_uuid: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Verdict per user server name. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
servers: {
|
||
[key: string]: "retiring" | "start_failed" | "owner" | "wake" | "owner_only" | "allowlist";
|
||
};
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
createLinkCode: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
mc_uuid: string;
|
||
/**
|
||
* @description Which Yggdrasil authenticated the in-game UUID (spec §10 dual-Yggdrasil). Optional; when omitted it is derived from the UUID's version nibble (felis-nano rewrites third-party profiles to UUIDv3; Mojang profiles are v4), defaulting to mojang. Captured here because only the in-game side sees the authentication; it is copied onto the link at verify.
|
||
* @enum {string}
|
||
*/
|
||
auth_source?: "mojang" | "thirdparty";
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Code minted. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
code: string;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
/** @description Where to redeem the code (https://<panel hostname>). Present only when a panel hostname is configured, so the in-game message can print a clickable destination. */
|
||
panel_url?: string;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
linkStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
mc_uuid: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Link-completion status. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
linked: boolean;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
migrateStart: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: uuid */
|
||
mc_uuid: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Migration opened in the initiated state. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
started: true;
|
||
/** @constant */
|
||
state: "initiated";
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The UUID is not linked to any account (not_linked). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The source account has already been retired by a completed migration (account_retired). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
reclaimUsername: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: uuid */
|
||
squatter_uuid: string;
|
||
username: string;
|
||
/** @description Optional opaque handle to the data already archived for the hold (server-side only, never returned). Archival may be deferred, in which case this is omitted. */
|
||
data_ref?: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Reclaim recorded. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
blacklisted: true;
|
||
username: string;
|
||
/** Format: date-time */
|
||
hold_expires_at: string;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The linked account holds a staff role and is never reclaimed (protected_admin). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
checkUsernameBlacklist: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
mc_uuid: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Blacklist status. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
blacklisted: boolean;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
opLoginPending: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The pending requests awaiting an in-game vouch. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
pending: {
|
||
request_id: string;
|
||
username: string;
|
||
email: string;
|
||
/** @description Where start was called from; empty on requests from before this was recorded. */
|
||
client_ip: string;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
}[];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
opLoginShow: {
|
||
parameters: {
|
||
query: {
|
||
approver_uuid: string;
|
||
};
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The pending request and where it was started. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
request_id: string;
|
||
username: string;
|
||
email: string;
|
||
/** @description Where start was called from; empty on requests from before this was recorded. */
|
||
client_ip: string;
|
||
/** @description The browser's User-Agent at start, up to 256 bytes; may be empty. */
|
||
user_agent: string;
|
||
/** Format: date-time */
|
||
created_at: string;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description approver_uuid is required (bad_request). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The approver is not a linked administrator (not_admin). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description No pending operator login with that id (op_login_not_found). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
opLoginApprove: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: uuid */
|
||
approver_uuid: string;
|
||
/** @description The account name the admin typed to confirm whose sign-in this is. */
|
||
username: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The vouch was recorded; the request is now approved. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
approved: true;
|
||
username: string;
|
||
email: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description approver_uuid and username are required (bad_request). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The approver is not a linked administrator (not_admin). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description No pending operator login with that id (op_login_not_found). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The typed name is not the request's account (op_login_mismatch). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
internalBackupNow: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
/** @description Optional accountability hint. The console passes the OS user at the keyboard so the audit row names the operator rather than the generic "break-glass"; absent/blank falls back to "break-glass". */
|
||
requestBody?: {
|
||
content: {
|
||
"application/json": {
|
||
os_user?: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Backup started. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
status: "backing_up";
|
||
};
|
||
};
|
||
};
|
||
/** @description Invalid server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Unknown server. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (not_stopped), a restore, backup or file write already holds its world volume (maintenance_in_progress), or the file changed since expect_sha256 was read (file_changed). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
wake: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Wake accepted. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
desiredState: "Running";
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Nothing was started. maintenance_in_progress: a restore, backup or file write holds the server's world volume. server_retiring: the server is given up or being deleted (ServerInfo.retiring). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Wake cooldown is still active. */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The node is at its running-server cap (at_capacity). */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
stop: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Stop accepted. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
desiredState: "Stopped";
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
emergencyStop: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
confirm: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Stop intent persisted and workload scaled to zero; await Pod termination. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
desiredState: "Stopped";
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
restart: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Restart accepted. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
desiredState: "Running";
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Server is not running, is retiring, or maintenance is in progress. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
claim: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Claimed. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
claimed: true;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Quota exceeded. */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
/** @description already_claimed: someone else owns it. server_retiring: the server is being deleted. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Account not linked (the pointer /account/link/start emits). */
|
||
412: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
command: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
command: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Command output. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
output: string;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Server not running. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
serverConsole: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: {
|
||
/** @description The id of the last line received; resumes the stream from that second (within the hour). */
|
||
"Last-Event-ID"?: string;
|
||
};
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description An event stream of log lines (`id:` + `data:` per line, `:` comments as keep-alives), ended by `event: revoked` when access is withdrawn. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"text/event-stream": string;
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server not running. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description This session already holds as many console streams as it may (too_many_streams). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
accessWhitelistList: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Whitelisted players. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
players: string[];
|
||
output: string;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Server not running. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
accessWhitelist: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @enum {string} */
|
||
action: "add" | "remove";
|
||
player: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
200: components["responses"]["AccessResult"];
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Server not running. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
accessPlayers: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Online players. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
online: number;
|
||
max: number;
|
||
players: string[];
|
||
output: string;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Server not running. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
accessBanList: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Banned players. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
players: string[];
|
||
output: string;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Server not running. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
accessBan: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @enum {string} */
|
||
action: "ban" | "pardon";
|
||
player: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
200: components["responses"]["AccessResult"];
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Server not running. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
accessKick: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
player: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The player was kicked; the raw RCON reply is in output. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
player: string;
|
||
output: string;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Server not running. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
accessPermission: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @enum {string} */
|
||
action: "set" | "unset";
|
||
player: string;
|
||
node: string;
|
||
/** @description set only; omitted => true (grant) */
|
||
value?: boolean;
|
||
/** @description optional LuckPerms world context */
|
||
world?: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
200: components["responses"]["AccessResult"];
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description not_running (the server is not running) or luckperms_missing (the server answered the lp command as unknown: LuckPerms is not installed, and nothing changed). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
accessGroup: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @enum {string} */
|
||
action: "add" | "remove";
|
||
player: string;
|
||
group: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
200: components["responses"]["AccessResult"];
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description not_running (the server is not running) or luckperms_missing (the server answered the lp command as unknown: LuckPerms is not installed, and nothing changed). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
accessLuckPermsInfo: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
player: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Parsed LuckPerms state plus the raw command output. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
player: string;
|
||
groups: string[];
|
||
permissions: {
|
||
node: string;
|
||
/** @description false = negated (§c) node */
|
||
value: boolean;
|
||
/** @description present only for world-scoped nodes */
|
||
world?: string;
|
||
}[];
|
||
output: string;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description not_running (the server is not running) or luckperms_missing (the server answered the lp command as unknown: LuckPerms is not installed, and nothing changed). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
listAllowlist: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The allowlist. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
server: string;
|
||
entries: components["schemas"]["AllowlistEntry"][];
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
setAllowlistWake: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
uuid: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
can_wake: boolean;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Changed. */
|
||
204: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description No such server, or the UUID is not on its allowlist. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
retireServer: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description The server's name */
|
||
confirm: string;
|
||
/** @description Delete the server (admin only). Default false gives it up. */
|
||
delete?: boolean;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Recorded; the server is stopped. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
retiring: components["schemas"]["RetireState"];
|
||
};
|
||
};
|
||
};
|
||
/** @description A malformed body or name, or confirm does not match the name (confirm_mismatch). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Neither the owner nor an admin, or an owner asking to delete. */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
/** @description system_server: a system server is never given up or deleted. world_volume_orphaned: the server is gone from the cluster but its world volume remains, which an operator archives and removes by hand. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
cancelRetire: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Nothing is pending any more. */
|
||
204: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Neither the owner nor an admin, or an owner cancelling an admin's deletion. */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
status: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The server's status projection (trimmed for non-owners). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["ServerInfo"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
authOptions: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: email */
|
||
email: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The login methods available for the address, in a deterministic order (passkey before email_otp). email_otp is offered only when the install has a mail relay, passkey only when a verifier is wired and the account has a credential. An empty array means no verified account, or none of its methods is available on this install. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
methods: ("passkey" | "email_otp")[];
|
||
};
|
||
};
|
||
};
|
||
/** @description A valid email is required (bad_request). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled on this deployment (local_auth_disabled). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request body was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
429: components["responses"]["RateLimited"];
|
||
};
|
||
};
|
||
passkeyLoginBegin: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: email */
|
||
email: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The WebAuthn assertion options (PublicKeyCredentialRequestOptions), passed through verbatim from the authenticator library for the browser to consume. The body is the WebAuthn standard shape and is not modelled here. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
[key: string]: unknown;
|
||
};
|
||
};
|
||
};
|
||
/** @description Invalid email (bad_request); or no passkey is enrolled for the account, or the address is unknown — indistinguishable by design (no_passkey); or the authenticator library could not start the ceremony (passkey_login_failed). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled on this deployment (local_auth_disabled). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request body was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description This network already holds 32 live passkey login challenges (too_many_challenges); or this client address called the sign-in doors too often (rate_limited, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description No passkey verifier is wired on this deployment (passkey_unavailable). */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
passkeyLoginFinish: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: email */
|
||
email: string;
|
||
/** @description The raw PublicKeyCredential from navigator.credentials.get(), passed to the verifier verbatim (WebAuthn standard shape). */
|
||
assertion: {
|
||
[key: string]: unknown;
|
||
};
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Assertion verified; a host-only session cookie is set on the response. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
user_id: string;
|
||
/** @enum {string} */
|
||
role: "owner" | "admin" | "user";
|
||
};
|
||
};
|
||
};
|
||
/** @description Invalid email or missing assertion (bad_request); or the login could not be completed — unknown address, no live or expired challenge, a failed assertion, no user verification, or a cloned authenticator, all uniform (passkey_login_invalid). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled on this deployment (local_auth_disabled). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request body was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
429: components["responses"]["RateLimited"];
|
||
/** @description No passkey verifier is wired on this deployment (passkey_unavailable). */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
passkeyLoginDiscoverableBegin: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
/** @description No body is read — the whole point is that the caller supplies no identifier — but the application/json Content-Type is required (415 otherwise). */
|
||
requestBody?: {
|
||
content: {
|
||
"application/json": Record<string, never>;
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The WebAuthn assertion options (PublicKeyCredentialRequestOptions) with an empty allowCredentials, passed through verbatim for the browser to consume, plus an opaque login_id the caller echoes at finish. The publicKey member is the WebAuthn standard shape and is not modelled here. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
publicKey: {
|
||
[key: string]: unknown;
|
||
};
|
||
login_id: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description The authenticator library could not start the ceremony (passkey_login_failed). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled on this deployment (local_auth_disabled). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request Content-Type was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description This network already holds 32 live discoverable challenges, or the store is at its global cap (too_many_challenges); or this client address called the sign-in doors too often (rate_limited, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description No passkey verifier is wired on this deployment (passkey_unavailable). */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
passkeyLoginDiscoverableFinish: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description The opaque handle returned by discoverable/begin. */
|
||
login_id: string;
|
||
/** @description The raw PublicKeyCredential from navigator.credentials.get(), passed to the verifier verbatim (WebAuthn standard shape). Its userHandle selects the account server-side. */
|
||
assertion: {
|
||
[key: string]: unknown;
|
||
};
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Assertion verified; a host-only session cookie is set on the response. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
user_id: string;
|
||
/** @enum {string} */
|
||
role: "owner" | "admin" | "user";
|
||
};
|
||
};
|
||
};
|
||
/** @description Missing login_id or assertion (bad_request); or the login could not be completed — no live/expired/consumed challenge, a failed assertion, no user verification, a cloned authenticator, or a userHandle that resolves to no account, all uniform (passkey_login_invalid). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled on this deployment (local_auth_disabled). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request body was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
429: components["responses"]["RateLimited"];
|
||
/** @description No passkey verifier is wired on this deployment (passkey_unavailable). */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
loginEmailStart: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: email */
|
||
email: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Accepted (neutral): a code was mailed if the address has a verified account; the response is identical either way. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
sent: true;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description A valid email is required (bad_request). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled on this deployment (local_auth_disabled). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request body was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description This client address called the sign-in doors too often (rate_limited, with Retry-After); or the install-wide mail budget is spent (mail_rate_limited, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
502: components["responses"]["MailUndeliverable"];
|
||
503: components["responses"]["MailUnavailable"];
|
||
};
|
||
};
|
||
loginEmailVerify: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: email */
|
||
email: string;
|
||
code: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Code accepted; a host-only session cookie is set on the response. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
user_id: string;
|
||
/** @enum {string} */
|
||
role: "owner" | "admin" | "user";
|
||
};
|
||
};
|
||
};
|
||
/** @description A valid email and code are required (bad_request); or the code is wrong, expired, or exhausted (invalid_code, uniform with an unknown address). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled (local_auth_disabled), or the account is staff and must sign in at the operator console (staff_account). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request body was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
429: components["responses"]["RateLimited"];
|
||
};
|
||
};
|
||
opLoginStart: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: email */
|
||
email: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Accepted (neutral): a request handle to poll. For a staff address a code was mailed and the handle is real; otherwise the handle is a random no-op. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
request_id: string;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description A valid email is required (bad_request). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled on this deployment (local_auth_disabled). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request body was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description This client address called the sign-in doors too often (rate_limited, with Retry-After); or the install-wide mail budget is spent (mail_rate_limited, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
502: components["responses"]["MailUndeliverable"];
|
||
503: components["responses"]["MailUnavailable"];
|
||
};
|
||
};
|
||
opLoginStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The approval state of the request handle. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
approved: boolean;
|
||
};
|
||
};
|
||
};
|
||
/** @description Local session login is disabled on this deployment (local_auth_disabled). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
opLoginFinish: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
request_id: string;
|
||
code: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Both factors proven; a host-only session cookie is set on the response. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
user_id: string;
|
||
/** @enum {string} */
|
||
role: "owner" | "admin" | "user";
|
||
};
|
||
};
|
||
};
|
||
/** @description request_id and code are required (bad_request); or the login could not be completed — unknown handle, not approved, wrong or locked code, an account disabled or deleted since the start, or lost race, all uniform (op_login_invalid). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled (local_auth_disabled), or the resolved account is not an operator (staff_account). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request body was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
429: components["responses"]["RateLimited"];
|
||
};
|
||
};
|
||
setupRedeem: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
token: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Token redeemed; a session cookie is set and the setup state is returned. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
user_id: string;
|
||
username: string;
|
||
/** @enum {string} */
|
||
role: "owner" | "admin" | "user";
|
||
email: string;
|
||
email_verified: boolean;
|
||
has_passkey: boolean;
|
||
setup_required: boolean;
|
||
};
|
||
};
|
||
};
|
||
/** @description A token is required (bad_request), or it is unknown, already used, or expired (setup_token_invalid). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local session login is disabled on this deployment (local_auth_disabled). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Request body was not application/json. */
|
||
415: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
429: components["responses"]["RateLimited"];
|
||
500: components["responses"]["InternalError"];
|
||
};
|
||
};
|
||
setupStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The caller's current setup state. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
user_id: string;
|
||
username: string;
|
||
/** @enum {string} */
|
||
role: "owner" | "admin" | "user";
|
||
email: string;
|
||
email_verified: boolean;
|
||
has_passkey: boolean;
|
||
setup_required: boolean;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The principal's user row was not found (not_found). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
ownerStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Whether any Owner or admin account exists. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
owner_bound: boolean;
|
||
};
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
logout: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Logged out (idempotent). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
ok: true;
|
||
};
|
||
};
|
||
};
|
||
};
|
||
};
|
||
bindRedeem: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
code: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Player account bootstrapped; the session cookie is set on the response. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
user_id: string;
|
||
/** @constant */
|
||
linked: true;
|
||
mc_uuid: string;
|
||
/**
|
||
* @description The source captured at mint, copied onto the durable link.
|
||
* @enum {string}
|
||
*/
|
||
auth_source: "mojang" | "thirdparty";
|
||
};
|
||
};
|
||
};
|
||
/** @description Invalid or expired bind code. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Local sessions are disabled, or the code's UUID belongs to a staff account. */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
429: components["responses"]["RateLimited"];
|
||
};
|
||
};
|
||
me: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The caller's identity. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
user_id: string;
|
||
/** Format: email */
|
||
email: string;
|
||
/**
|
||
* @description The principal's role, mirroring users.role.
|
||
* @enum {string}
|
||
*/
|
||
role: "user" | "admin" | "owner";
|
||
/** @description True only when role is admin or owner AND the request arrived on the operator console host (Principal.IsAdmin()). */
|
||
is_admin: boolean;
|
||
/** @description True only for the Owner principal on the operator console host (Principal.IsOwner()); gates owner-only panel surfaces. */
|
||
is_owner: boolean;
|
||
/** @description Whether the account's email has been verified; the panel nudges unverified accounts through the email-OTP flow. */
|
||
email_verified: boolean;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The account settings could not be read (auth_unavailable). */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
myServers: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The caller's server list. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
servers: components["schemas"]["MyServerView"][];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
nodeTasks: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Availability and most recent task records; no credentials or logs. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
available: boolean;
|
||
tasks: components["schemas"]["NodeControlTask"][];
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Another node task is running or this task cannot be retried. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Host node execution service is unavailable. */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
};
|
||
};
|
||
startNodeTask: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": components["schemas"]["NodeControlRequest"];
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Persistent task created. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["NodeControlTask"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Another node task is running or this task cannot be retried. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Host node execution service is unavailable. */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
};
|
||
};
|
||
nodeTask: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Current task and recent output. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["NodeControlTask"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Another node task is running or this task cannot be retried. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Host node execution service is unavailable. */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
};
|
||
};
|
||
retryNodeTask: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description New task created; original task is retained. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["NodeControlTask"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Another node task is running or this task cannot be retried. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Host node execution service is unavailable. */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
};
|
||
};
|
||
getWakePolicy: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Current startup policy and revision. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["WakePolicySettings"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
setWakePolicy: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
maxRunningServers: number;
|
||
wakeCooldownSeconds: number;
|
||
revision: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Saved policy and new revision. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["WakePolicySettings"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description The policy changed; reload before saving. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
getAuthSources: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Current third-party sources and their revision. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["AuthSourcesSettings"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
setAuthSources: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
sources: components["schemas"]["AuthSourceConfig"][];
|
||
revision: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Saved configuration and new revision. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["AuthSourcesSettings"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description auth_sources_changed or auth_source_tag_locked; reload instead of overwriting another Owner's changes. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
testAuthSource: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": components["schemas"]["AuthSourceConfig"];
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Probe result; non-204 status has ok=false. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
ok: boolean;
|
||
status: number;
|
||
/** Format: int64 */
|
||
elapsed_ms: number;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
getUpdateWindow: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The current maintenance window (both ends null when unset). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["UpdateWindow"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
setUpdateWindow: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": components["schemas"]["UpdateWindow"];
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The stored maintenance window (echoed back). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["UpdateWindow"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
getDBBackup: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The newest recorded backup and whether it is stale. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["DBBackupStatus"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
getUpdateReport: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The newest recorded check and whether it is stale. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["UpdateReport"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
fleet: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Every server's status projection (fleet-wide), each with its owner. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
servers: components["schemas"]["FleetServer"][];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
listBackups: {
|
||
parameters: {
|
||
query?: {
|
||
/** @description Only this server's backups */
|
||
server?: string;
|
||
limit?: number;
|
||
offset?: number;
|
||
};
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description A page of visible backups plus how many match. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
backups: components["schemas"]["BackupView"][];
|
||
total: number;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
deleteBackup: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The backup is deleted; its archive goes at the reaper's next run. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
id: string;
|
||
/** @constant */
|
||
status: "expired";
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description No present backup with this id in the caller's scope (no_backup). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A restore running on the backup's server may be reading it (restore_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
restoreBackup: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description Which backup to restore; defaults to the latest for the server. */
|
||
backup_id?: string;
|
||
/**
|
||
* @description Back up the current world before overwriting it.
|
||
* @default true
|
||
*/
|
||
safety_snapshot?: boolean;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Restore started (after the safety snapshot when safety_snapshot is true). */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
status: "restoring";
|
||
backup_id: string;
|
||
/** @description Whether a safety snapshot runs first. False when the request turned it off, or when this install cannot take one. */
|
||
safety_snapshot: boolean;
|
||
};
|
||
};
|
||
};
|
||
/** @description Malformed server name (bad_name) or request body. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description No matching backup. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (not_stopped), a restore, backup or file write already holds its world volume (maintenance_in_progress), a restore of another backup is still running (restore_in_progress), or the chosen backup failed a read-back (backup_corrupt). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
backupNow: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Backup started. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
/** @constant */
|
||
status: "backing_up";
|
||
};
|
||
};
|
||
};
|
||
/** @description Malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (not_stopped), or a restore, backup or file write already holds its world volume (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Another backup of this server started within the cooldown (backup_cooldown). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
507: components["responses"]["InsufficientStorage"];
|
||
};
|
||
};
|
||
exportBackup: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Export started. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["ExportTicket"];
|
||
};
|
||
};
|
||
/** @description Malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or no present backup with this id in the caller's scope (no_backup). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The backup failed a read-back (backup_corrupt). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description An export limit is reached (export_busy); Retry-After gives the seconds to wait. */
|
||
429: {
|
||
headers: {
|
||
"Retry-After"?: number;
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
exportWorld: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Export started. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["ExportTicket"];
|
||
};
|
||
};
|
||
/** @description Malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (not_stopped), has no world volume yet (no_world_volume), or a restore, backup, file write or export already holds its world volume (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description An export limit is reached (export_busy); Retry-After gives the seconds to wait. */
|
||
429: {
|
||
headers: {
|
||
"Retry-After"?: number;
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
exportStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
ticket: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The export's state. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["ExportStatus"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description The export was downloaded, or expired before it was (export_expired). */
|
||
410: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
exportDownload: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
ticket: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The export as an attachment: a world or a backup as a tar.gz, a downloaded folder as a zip, a downloaded file as its bytes. */
|
||
200: {
|
||
headers: {
|
||
"Content-Disposition"?: string;
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/gzip": string;
|
||
"application/zip": string;
|
||
"application/octet-stream": string;
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description A method other than GET (method_not_allowed). */
|
||
405: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The export is still pending (export_not_ready). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The export was downloaded, failed, or expired before it was (export_expired). */
|
||
410: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
listServerJobs: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The server's newest backup, restore and export jobs. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
server: string;
|
||
jobs: {
|
||
name: string;
|
||
/** @enum {string} */
|
||
kind: "backup" | "restore" | "export_world" | "export_backup" | "export_files";
|
||
/** @enum {string} */
|
||
state: "running" | "succeeded" | "failed";
|
||
message?: string;
|
||
/** Format: date-time */
|
||
started_at?: string;
|
||
/** Format: date-time */
|
||
finished_at?: string;
|
||
/**
|
||
* @description Set on a restore's safety snapshot (a backup job): pending until the restore behind it starts, or abandoned with then_restore_reason saying why (its English wording is in message).
|
||
* @enum {string}
|
||
*/
|
||
then_restore?: "pending" | "started" | "abandoned";
|
||
/**
|
||
* @description Why an abandoned chain was given up.
|
||
* @enum {string}
|
||
*/
|
||
then_restore_reason?: "snapshot_failed" | "not_configured" | "server_gone" | "server_started" | "restore_busy";
|
||
/** @description The backup the chained restore extracts. */
|
||
restore_backup_id?: string;
|
||
/** @description A backup felis-api took on its own: the daily restore point of a played world. Omitted when false. */
|
||
scheduled?: boolean;
|
||
}[];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
listServerFiles: {
|
||
parameters: {
|
||
query?: {
|
||
/** @description Directory to list, relative to the world root. Empty lists the root itself. */
|
||
path?: string;
|
||
};
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Directory listing. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
path: string;
|
||
/** @description The listing hit the entry cap and is incomplete. */
|
||
truncated: boolean;
|
||
/**
|
||
* Format: int64
|
||
* @description Bytes free on the world volume
|
||
*/
|
||
free_bytes: number | null;
|
||
entries: {
|
||
name: string;
|
||
/** Format: int64 */
|
||
size: number;
|
||
is_dir: boolean;
|
||
/** Format: date-time */
|
||
mod_time: string;
|
||
}[];
|
||
};
|
||
};
|
||
};
|
||
/** @description Invalid server name, or a path that escapes the world root. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or no such directory. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (its world PVC is still mounted). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description The file Job did not finish in time; retry. */
|
||
504: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
readServerFile: {
|
||
parameters: {
|
||
query: {
|
||
/** @description File to read, relative to the world root. */
|
||
path: string;
|
||
};
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description File contents. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
path: string;
|
||
/**
|
||
* Format: byte
|
||
* @description Base64-encoded file bytes.
|
||
*/
|
||
content: string;
|
||
/** @description SHA-256 of the file as stored (before secret redaction in server.properties). Send it back as expect_sha256 on the next write. */
|
||
sha256: string;
|
||
/** @description SHA-256 of the decoded content as sent (after any redaction). A client that gets content hashing otherwise got it damaged on the way, and reads it again. */
|
||
content_sha256: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description Missing path, invalid server name, or a path that escapes the world root. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or no such file. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (except startup-only system experience config). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The file is larger than the editor reads. */
|
||
413: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The file's bytes do not hash to the digest the file Job sent with them (read_damaged): they changed on the way to felis-api. Read it again. */
|
||
502: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description The file Job did not finish in time; retry. */
|
||
504: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
507: components["responses"]["InsufficientStorage"];
|
||
};
|
||
};
|
||
writeServerFile: {
|
||
parameters: {
|
||
query: {
|
||
/** @description File to write, relative to the world root. */
|
||
path: string;
|
||
};
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/**
|
||
* Format: byte
|
||
* @description Base64-encoded file bytes.
|
||
*/
|
||
content: string;
|
||
/** @description The SHA-256 (lowercase hex) of the decoded content. Absent is 400 digest_required, malformed 400 bad_digest, and content that does not hash to it 400 digest_mismatch; nothing is written. */
|
||
content_sha256: string;
|
||
/** @description The sha256 a read returned. When present, the write is refused with 409 file_changed if the file has changed (or been deleted) since. Omit it to write unconditionally. */
|
||
expect_sha256?: string;
|
||
/** @description true writes only if nothing is at the path yet (409 file_exists otherwise), for making a new file without replacing one that appeared meanwhile. Cannot be combined with expect_sha256. */
|
||
create_only?: boolean;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description File written. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
path: string;
|
||
/** @constant */
|
||
status: "written";
|
||
/** @description SHA-256 of the bytes written. */
|
||
sha256: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description Missing path, malformed body, invalid server name, or a path that escapes the world root (bad_request, bad_path), or content that came without its SHA-256 (digest_required), with a malformed one (bad_digest), or changed on the way (digest_mismatch). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or the parent directory does not exist. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The file changed since expect_sha256 was read (file_changed), something is already at the path with create_only (file_exists), the server is not stopped (not_stopped), or a restore, backup or file change already holds its world volume (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The content is larger than the editor writes. */
|
||
413: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description The file Job did not finish in time; retry. */
|
||
504: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The world volume has no room for the write (volume_full); the file is unchanged. */
|
||
507: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
deleteServerFile: {
|
||
parameters: {
|
||
query: {
|
||
/** @description File or folder to delete, relative to the world root. */
|
||
path: string;
|
||
};
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Deleted. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
path: string;
|
||
/** @constant */
|
||
status: "deleted";
|
||
};
|
||
};
|
||
};
|
||
/** @description Missing path, invalid server name, the world root, or a path that escapes it. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or nothing at the path. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (not_stopped), or a restore, backup or file change already holds its world volume (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description The file Job did not finish in time; retry. */
|
||
504: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
makeServerFolder: {
|
||
parameters: {
|
||
query: {
|
||
/** @description Folder to make, relative to the world root. */
|
||
path: string;
|
||
};
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Folder made. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
path: string;
|
||
/** @constant */
|
||
status: "created";
|
||
};
|
||
};
|
||
};
|
||
/** @description Missing path, invalid server name, the world root, or a path that escapes it. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or the parent folder does not exist. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Something is already at the path (file_exists), the server is not stopped (not_stopped), or a restore, backup or file change already holds its world volume (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description The file Job did not finish in time; retry. */
|
||
504: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
renameServerFile: {
|
||
parameters: {
|
||
query: {
|
||
/** @description File or folder to move, relative to the world root. */
|
||
path: string;
|
||
};
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description The new path */
|
||
to: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Moved. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
path: string;
|
||
to: string;
|
||
/** @constant */
|
||
status: "renamed";
|
||
};
|
||
};
|
||
};
|
||
/** @description Missing path or to, malformed body, invalid server name, the world root, a file felis manages, or a path that escapes the world root. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, nothing at path, or the destination folder does not exist. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Something is already at to (file_exists), the server is not stopped (not_stopped), or a restore, backup or file change already holds its world volume (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description The file Job did not finish in time; retry. */
|
||
504: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
downloadServerFile: {
|
||
parameters: {
|
||
query: {
|
||
/** @description File or folder to download, relative to the world root. The root itself is refused. */
|
||
path: string;
|
||
/** @description true when path is a folder, which is sent as a zip. The Job refuses a path that is not what dir says. */
|
||
dir?: "true" | "false";
|
||
};
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Download started. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["ExportTicket"];
|
||
};
|
||
};
|
||
/** @description Missing path (bad_request), the world root (bad_path), or a malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (not_stopped), has no world volume yet (no_world_volume), or a restore, backup, file change or another export already holds its world volume (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A file download limit is reached (export_busy); Retry-After gives the seconds to wait. */
|
||
429: {
|
||
headers: {
|
||
"Retry-After"?: number;
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
uploadServerFile: {
|
||
parameters: {
|
||
query: {
|
||
/** @description File to create, relative to the world root. Its folder must exist. */
|
||
path: string;
|
||
/** @description true replaces an existing file, keeping its mode. Anything else refuses to. */
|
||
overwrite?: "true" | "false";
|
||
};
|
||
header: {
|
||
/** @description The SHA-256 of the body as RFC 9530 sends it, sha-256=:<base64>:. Other algorithms listed beside it are ignored. Bytes that do not hash to it were changed on the way and are refused whole. */
|
||
"Content-Digest": string;
|
||
};
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/octet-stream": string;
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description File uploaded. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
path: string;
|
||
/** @constant */
|
||
status: "uploaded";
|
||
/** @description SHA-256 of the bytes landed. */
|
||
sha256: string;
|
||
/**
|
||
* Format: int64
|
||
* @description Bytes landed.
|
||
*/
|
||
size: number;
|
||
};
|
||
};
|
||
};
|
||
/** @description Missing path, invalid server name, a folder or the world root at the path, a path that escapes the world root, a body that ended before Content-Length bytes arrived (upload_incomplete), no Content-Digest (digest_required), a malformed one (bad_digest), or bytes that do not hash to it (digest_mismatch; nothing is staged, so send it again). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or the folder does not exist. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A file is already at the path and overwrite is not true (file_exists), the server is not stopped (not_stopped), or a restore, backup or file change already holds its world volume (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The request has no Content-Length (length_required). */
|
||
411: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The file is over 64 MiB, the most one request carries (too_large); send it as an upload session instead. */
|
||
413: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description The file Job did not finish in time; retry. */
|
||
504: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description felis-api's staging disk has no room for the upload right now (upload_staging_full), or the world volume has no room for it (volume_full); nothing was changed. */
|
||
507: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
beginServerFileUpload: {
|
||
parameters: {
|
||
query: {
|
||
/** @description File to create, relative to the world root. It must stay inside it (400 bad_path); its folder is checked when the file lands. */
|
||
path: string;
|
||
};
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/**
|
||
* Format: int64
|
||
* @description The file's length in bytes.
|
||
*/
|
||
size: number;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Session begun. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["FileUploadSession"];
|
||
};
|
||
};
|
||
/** @description Missing path or size, or a negative size (bad_request), a path leaving the world folder or naming the folder itself (bad_path), or a malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (not_stopped) or has no world volume yet (no_world_volume). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The account already has 4 uploads in progress (too_many_uploads). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description felis-api's staging disk has no room for a file this size right now (upload_staging_full). */
|
||
507: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
getServerFileUpload: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The session. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["FileUploadSession"];
|
||
};
|
||
};
|
||
/** @description Malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or no such session for this account on this server (upload_not_found). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
putServerFileUploadPart: {
|
||
parameters: {
|
||
query: {
|
||
/** @description The byte position the part starts at, the session's received. */
|
||
offset: number;
|
||
};
|
||
header: {
|
||
/** @description The SHA-256 of the body as RFC 9530 sends it, sha-256=:<base64>:. Other algorithms listed beside it are ignored. Bytes that do not hash to it were changed on the way and are refused whole. */
|
||
"Content-Digest": string;
|
||
};
|
||
path: {
|
||
name: string;
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/octet-stream": string;
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Part taken. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["FileUploadSession"];
|
||
};
|
||
};
|
||
/** @description A missing or malformed offset (bad_request), a body that ended before its Content-Length (upload_incomplete), no Content-Digest (digest_required), a malformed one (bad_digest), bytes that do not hash to it (digest_mismatch; the part was not taken, so send it again), or a malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or no such session for this account on this server (upload_not_found). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description offset is not where the session ends (upload_offset_mismatch), or another part is still arriving (upload_busy). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The request has no Content-Length (length_required). */
|
||
411: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The part is over part_max_bytes, or runs past the size the session began with (part_too_large). */
|
||
413: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description felis-api's staging disk ran out of room (upload_staging_full). */
|
||
507: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
deleteServerFileUpload: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Cancelled. */
|
||
204: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or no such session for this account on this server (upload_not_found). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A part is still arriving (upload_busy). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
commitServerFileUpload: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": components["schemas"]["StartFileOp"];
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Landing started. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
op: components["schemas"]["FileOp"];
|
||
};
|
||
};
|
||
};
|
||
/** @description Malformed body, or a malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server, or no such session for this account on this server (upload_not_found). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Not every byte has arrived (upload_incomplete; the world lock is not asked for), a part is still arriving (upload_busy), the server is not stopped (not_stopped) or has no world volume yet (no_world_volume), or a restore, backup, file change or export already holds its world volume, this session's earlier commit included (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
unzipServerFile: {
|
||
parameters: {
|
||
query: {
|
||
/** @description The .zip to extract, relative to the world root. */
|
||
path: string;
|
||
};
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": components["schemas"]["StartFileOp"];
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Extraction started. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
op: components["schemas"]["FileOp"];
|
||
};
|
||
};
|
||
};
|
||
/** @description Missing path or malformed body (bad_request), a path not ending in .zip (bad_path), or a malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Server is not stopped (not_stopped), has no world volume yet (no_world_volume), or a restore, backup, file change or export already holds its world volume (maintenance_in_progress). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
listServerFileOps: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The ops. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
ops: components["schemas"]["FileOp"][];
|
||
};
|
||
};
|
||
};
|
||
/** @description Malformed server name (bad_name). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown server. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
listServerSchedules: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The server's tasks, oldest first, and how many it may have. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
server: string;
|
||
schedules: components["schemas"]["Schedule"][];
|
||
limit: number;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
createServerSchedule: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": components["schemas"]["ScheduleInput"];
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Created. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Schedule"];
|
||
};
|
||
};
|
||
/** @description A malformed body or name, or settings out of range (bad_schedule, bad_request for the command). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description The server already has 20 tasks (schedule_limit). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
updateServerSchedule: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
id: number;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": components["schemas"]["ScheduleInput"];
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Saved. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Schedule"];
|
||
};
|
||
};
|
||
/** @description A malformed body, name or id, or settings out of range (bad_schedule). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description A run is in progress (schedule_running). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
deleteServerSchedule: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
id: number;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Removed. */
|
||
204: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description A run is in progress (schedule_running). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
runServerSchedule: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
id: number;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Started. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Schedule"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description A run is already in progress (schedule_running), or the server has another owner since the task was saved (schedule_stale). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
listUsers: {
|
||
parameters: {
|
||
query?: {
|
||
/** @description Substring match on username or email */
|
||
query?: string;
|
||
role?: "admin" | "user";
|
||
disabled?: "true" | "false";
|
||
limit?: number;
|
||
offset?: number;
|
||
};
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description A page of users plus the total unfiltered count. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
users: components["schemas"]["UserView"][];
|
||
total: number;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
createUser: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
username: string;
|
||
/** Format: email */
|
||
email?: string;
|
||
/** @enum {string} */
|
||
role: "admin" | "user";
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description User created. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["UserView"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Username already taken. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
getUser: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Full user detail including linked MC accounts. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["UserDetail"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
deleteUser: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description User soft-deleted. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
deleted: true;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Not an owner (forbidden); the caller's own account (self_protected); or the owner account (owner_protected), which only the host's break-glass console (sudo felis breakGlass) may remove. */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
patchUser: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
username?: string;
|
||
/** Format: email */
|
||
email?: string;
|
||
/** @enum {string} */
|
||
role?: "admin" | "user";
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Updated user. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["UserView"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Not an owner (forbidden); a change to the caller's own role (self_protected); a role change on the owner account (owner_protected), which only the host's break-glass console (sudo felis breakGlass) may make; or a change to the caller's own email without a reauth in the last 5 minutes (reauth_required). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Username conflict. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
disableUser: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
disabled: boolean;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Toggle applied. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
id: string;
|
||
disabled: boolean;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Not an owner (forbidden); the caller's own account (self_protected); or disabling the owner account (owner_protected). Re-enabling the owner is allowed. */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
};
|
||
};
|
||
getQuotas: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The user's current quotas (null=unlimited). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["QuotaView"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown user. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
setQuotas: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
max_servers?: number | null;
|
||
max_cpu_milli?: number | null;
|
||
max_memory_mb?: number | null;
|
||
max_storage_gb?: number | null;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Quotas updated. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["QuotaView"];
|
||
};
|
||
};
|
||
/** @description invalid_quota, a cap outside 0..2147483647; or a body that is not JSON or carries a fraction. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown user. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
listUserSessions: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Live sessions, most recently seen first. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
sessions: components["schemas"]["SessionView"][];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
revokeUserSessions: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description All sessions revoked. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
ok: true;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
revokeUserSession: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
hash: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Session revoked. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
ok: true;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description session_not_found — the hash is not a live session of this user (another user's, already ended, or unknown). Nothing is revoked. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
unbindUserPasskeys: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description All passkeys unbound (a no-op 200 when the user had none). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
ok: true;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Not an owner (forbidden); or unbinding the caller's own passkeys without a reauth in the last 5 minutes (reauth_required). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
linkAccount: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: uuid */
|
||
mc_uuid: string;
|
||
/**
|
||
* @default mojang
|
||
* @enum {string}
|
||
*/
|
||
auth_source?: "mojang" | "thirdparty";
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description UUID linked (or was already linked to this user). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
ok: true;
|
||
/** Format: uuid */
|
||
mc_uuid: string;
|
||
auth_source: string;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Unknown user. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description UUID is already linked to a different user. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
unlinkAccount: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
mc_uuid: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description UUID unlinked. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
ok: true;
|
||
/** Format: uuid */
|
||
mc_uuid: string;
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description No linked account for this UUID. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
linkSources: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Sources in game-authentication priority order; no upstream URLs are exposed. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
sources: {
|
||
tag: string;
|
||
lookup_available: boolean;
|
||
}[];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
};
|
||
};
|
||
lookupProfile: {
|
||
parameters: {
|
||
query: {
|
||
source: string;
|
||
profile: string;
|
||
};
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Role found. mc_uuid uses the exact same per-source mapping as game authentication. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
source: string;
|
||
name: string;
|
||
profile_uuid: string;
|
||
/** Format: uuid */
|
||
mc_uuid: string;
|
||
/** @enum {string} */
|
||
auth_source: "mojang" | "thirdparty";
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description No matching role in the selected source. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Source returned an invalid or mismatched profile. */
|
||
502: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Source unavailable. */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
};
|
||
};
|
||
linkProfile: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
source: string;
|
||
/** Format: uuid */
|
||
profile_uuid: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Role linked, idempotently for the same user and UUID. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
linked: boolean;
|
||
/** Format: uuid */
|
||
mc_uuid: string;
|
||
/** @enum {string} */
|
||
auth_source: "mojang" | "thirdparty";
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description Role no longer exists. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Role already linked to another user */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Source returned an invalid or mismatched profile. */
|
||
502: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description Source unavailable. */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
};
|
||
};
|
||
linkStart: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Current link status. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
linked: boolean;
|
||
instructions: string;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
linkVerify: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
code: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Linked. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
linked: true;
|
||
mc_uuid: string;
|
||
/**
|
||
* @description The source captured at mint, copied onto the durable link.
|
||
* @enum {string}
|
||
*/
|
||
auth_source: "mojang" | "thirdparty";
|
||
};
|
||
};
|
||
};
|
||
/** @description Invalid or expired code. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Account already linked. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
emailOtpStart: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: email */
|
||
email: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Code minted and mailed. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
sent: true;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description Missing or malformed email address. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["ReauthRequired"];
|
||
/** @description Resend requested before the cooldown elapsed (otp_resend_cooldown); or the account spent its daily wrong-code budget (otp_account_locked, with Retry-After); or the install-wide mail budget is spent (mail_rate_limited, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
502: components["responses"]["MailUndeliverable"];
|
||
503: components["responses"]["MailUnavailable"];
|
||
};
|
||
};
|
||
emailOtpVerify: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
code: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Email verified. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
verified: true;
|
||
/** Format: email */
|
||
email: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description Invalid or expired code. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Another account already proved this address (email_taken); the code is not consumed. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Too many incorrect attempts on this code (otp_locked), or the account's daily wrong-code budget is spent (otp_account_locked, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
setEmail: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** Format: email */
|
||
email: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Email recorded (unverified). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** Format: email */
|
||
email: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description A valid email is required. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["ReauthRequired"];
|
||
};
|
||
};
|
||
passkeyRegisterBegin: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description WebAuthn credential-creation options (the publicKey document). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": Record<string, never>;
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["ReauthRequired"];
|
||
/** @description Passkey subsystem is not configured. */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
passkeyRegisterFinish: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description Human nickname for the passkey (e.g. "My phone"). */
|
||
name?: string;
|
||
/** @description The raw navigator.credentials.create() result the browser posts back. */
|
||
attestation: Record<string, never>;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Passkey bound. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["PasskeyCredential"];
|
||
};
|
||
};
|
||
/** @description No live ceremony, or the attestation could not be verified. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description This passkey is already bound to an account. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Passkey subsystem is not configured. */
|
||
503: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
passkeyList: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The caller's bound passkeys. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
credentials: components["schemas"]["PasskeyCredential"][];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
passkeyDelete: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
/** @description The passkey row id (from the credential list). */
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Passkey unbound. */
|
||
204: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["ReauthRequired"];
|
||
/** @description No such passkey for this caller. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description last_passkey — this is the only passkey and the email is unverified. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
reauthStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Where the caller stands. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
needed: boolean;
|
||
/** Format: date-time */
|
||
until?: string;
|
||
factors: ("passkey" | "email" | "sign_in")[];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
reauthPasskeyBegin: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description WebAuthn assertion request options (PublicKeyCredentialRequestOptions) for navigator.credentials.get. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": Record<string, never>;
|
||
};
|
||
};
|
||
/** @description The caller has no enrolled passkey (no_passkey), or no browser session to mark (no_session). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
reauthPasskeyFinish: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description The navigator.credentials.get() PublicKeyCredential assertion. */
|
||
assertion: Record<string, never>;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
200: components["responses"]["Reauthed"];
|
||
/** @description Assertion invalid, challenge stale, no user verification, or a cloned authenticator (passkey_login_invalid); no browser session (no_session). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
reauthEmailStart: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Code minted and dispatched. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
sent: true;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description No browser session to mark (no_session). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Operators cannot reauth by email (staff_reauth). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The account has no verified email (no_step_up_factor). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Resend requested before the cooldown elapsed (otp_resend_cooldown); or the account's daily wrong-code budget is spent (otp_account_locked, with Retry-After); or the install-wide mail budget is spent (mail_rate_limited, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
502: components["responses"]["MailUndeliverable"];
|
||
503: components["responses"]["MailUnavailable"];
|
||
};
|
||
};
|
||
reauthEmailVerify: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
code: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
200: components["responses"]["Reauthed"];
|
||
/** @description Invalid or expired code (invalid_code), or no browser session (no_session). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description Operators cannot reauth by email (staff_reauth). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The account has no verified email (no_step_up_factor). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Too many incorrect attempts on this code (otp_locked), or the account's daily wrong-code budget is spent (otp_account_locked, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
listMySessions: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The caller's live sessions. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
sessions: components["schemas"]["SessionView"][];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
revokeMySession: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
hash: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Session revoked. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
ok: true;
|
||
/** @description True when the revoked session was the caller's own, which is now signed out. */
|
||
signed_out: boolean;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description session_not_found — not a live session of the caller. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
revokeMyOtherSessions: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Other sessions revoked. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @description How many sessions were signed out. */
|
||
revoked: number;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
migrateStatus: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The caller's live migration, or active:false. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
active: boolean;
|
||
/**
|
||
* @description Present only when active; a redeemed migration is terminal and not reported here.
|
||
* @enum {string}
|
||
*/
|
||
state?: "initiated" | "confirmed" | "code_issued";
|
||
target_user_id?: string;
|
||
/** @enum {string} */
|
||
confirm_factor?: "passkey" | "email_otp";
|
||
/**
|
||
* Format: date-time
|
||
* @description Present while state is confirmed; the code must be issued before it.
|
||
*/
|
||
confirm_expires_at?: string;
|
||
/** Format: date-time */
|
||
code_expires_at?: string;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
};
|
||
};
|
||
migrateConfirmOtpStart: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Confirmation code minted and dispatched. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
sent: true;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The caller has no initiated migration to confirm (no_migration). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description A passkey is enrolled so email-OTP is forbidden (passkey_required); the migration is already confirmed (already_confirmed); or the account has no email step-up factor (no_step_up_factor). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description Resend requested before the cooldown elapsed (otp_resend_cooldown), or the account's daily wrong-code budget is spent (otp_account_locked, with Retry-After); or the install-wide mail budget is spent (mail_rate_limited, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
502: components["responses"]["MailUndeliverable"];
|
||
503: components["responses"]["MailUnavailable"];
|
||
};
|
||
};
|
||
migrateConfirmOtpVerify: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
code: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Migration confirmed. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
confirmed: true;
|
||
};
|
||
};
|
||
};
|
||
/** @description Invalid or expired code (invalid_code). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The caller has no initiated migration to confirm (no_migration). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The migration is already confirmed (already_confirmed). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description The code is locked after too many wrong attempts (otp_locked), or the account's daily wrong-code budget is spent (otp_account_locked, with Retry-After). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
migrateConfirmPasskeyBegin: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description WebAuthn assertion request options (PublicKeyCredentialRequestOptions) for navigator.credentials.get. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": Record<string, never>;
|
||
};
|
||
};
|
||
/** @description The caller has no enrolled passkey (no_passkey). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The caller has no initiated migration to confirm (no_migration). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
migrateConfirmPasskeyFinish: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description The navigator.credentials.get() PublicKeyCredential assertion. */
|
||
assertion: Record<string, never>;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Migration confirmed. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
confirmed: true;
|
||
};
|
||
};
|
||
};
|
||
/** @description Assertion invalid, challenge stale, no user verification, or a cloned authenticator was detected (passkey_login_invalid). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The caller has no initiated migration to confirm (no_migration). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
migrateIssueCode: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
target_user_id: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Code minted, bound to the named target. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
code: string;
|
||
/** Format: date-time */
|
||
expires_at: string;
|
||
};
|
||
};
|
||
};
|
||
/** @description The target is the source itself (invalid_target), does not exist (target_not_found), or is disabled/retired (target_unavailable). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The caller has no migration to issue against (no_migration). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
/** @description No step-up from this session within the last 10 minutes, or a code is already out (not_confirmed). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
migrateRedeem: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
code: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Migration redeemed; owned servers moved to the caller. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** @constant */
|
||
migrated: true;
|
||
/** Format: int32 */
|
||
servers_moved: number;
|
||
servers: string[];
|
||
};
|
||
};
|
||
};
|
||
/** @description Unknown, expired, or already-spent code, or the caller is not the named target (invalid_code). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The source's servers would push the caller over a quota cap (migrate_quota_exceeded). Nothing moved and the code is unspent; it redeems once the quota fits, until it expires. */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
mySubmissions: {
|
||
parameters: {
|
||
query?: {
|
||
status?: "pending_review" | "approved" | "rejected";
|
||
/** @description Part of the id, the submitter or the display name; case-insensitive */
|
||
query?: string;
|
||
limit?: number;
|
||
offset?: number;
|
||
};
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description One page of the caller's submissions, newest first; rows with a linked build additionally carry build_status/build_error so the submitter can see whether their build succeeded or failed (and why). */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
submissions: components["schemas"]["Submission"][];
|
||
/** @description How many submissions match status and query in all. */
|
||
total: number;
|
||
/** @description How many of the scope's submissions sit in each status, whatever status and query say. */
|
||
counts: {
|
||
pending_review: number;
|
||
approved: number;
|
||
rejected: number;
|
||
};
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
createSubmission: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
display_name: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Submission recorded, pending review. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Submission"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The per-user submission allowance is spent — too many of the caller's submissions are awaiting review, or their stored-upload budget is full (submission_quota_exceeded). The budget counts pending uploads and rejected ones until they are reaped, 7 days after review; approved uploads leave it. */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
/** @description A submission was created within the per-user cooldown window (submission_cooldown). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
submissionLimits: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The cap. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
/** Format: int64 */
|
||
max_context_bytes: number;
|
||
};
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
uploadSubmissionContext: {
|
||
parameters: {
|
||
query?: never;
|
||
header: {
|
||
/** @description The SHA-256 of the body as RFC 9530 sends it, sha-256=:<base64>:. Other algorithms listed beside it are ignored. */
|
||
"Content-Digest": string;
|
||
};
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/gzip": string;
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Context stored; the submission (unchanged) is returned. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Submission"];
|
||
};
|
||
};
|
||
/** @description A body that is not a gzip tarball or is over the context cap (bad_request), no Content-Digest (digest_required), a malformed one (bad_digest), or bytes that do not hash to it (digest_mismatch; nothing was stored, so send it again). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The upload would exceed the caller's per-user stored-context budget (submission_quota_exceeded), which counts their pending and rejected uploads; approved ones leave it. */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
/** @description An upload was accepted within the per-user cooldown window (submission_cooldown). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
getContextUpload: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The staged length and the limits a part and the whole must keep. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["ContextUploadProgress"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
putContextUploadPart: {
|
||
parameters: {
|
||
query: {
|
||
offset: number;
|
||
};
|
||
header: {
|
||
/** @description The SHA-256 of the part as RFC 9530 sends it, sha-256=:<base64>:. Other algorithms listed beside it are ignored. */
|
||
"Content-Digest": string;
|
||
};
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/octet-stream": string;
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The part is staged; received is the new length. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["ContextUploadProgress"];
|
||
};
|
||
};
|
||
/** @description A missing or malformed offset, a first part without the gzip magic or a total over the context cap (bad_request), no Content-Digest (digest_required), a malformed one (bad_digest), or bytes that do not hash to it (digest_mismatch; the part was cut back off, so read where the upload stands and send it again). */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The staged total would exceed the caller's per-user stored-context budget (submission_quota_exceeded). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
/** @description The part is larger than part_max_bytes (part_too_large). */
|
||
413: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
/** @description The uploads store is full (uploads_full). */
|
||
507: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
};
|
||
};
|
||
completeContextUpload: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description Context stored; the submission (unchanged) is returned. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Submission"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
/** @description The context would exceed the caller's per-user stored-context budget (submission_quota_exceeded). */
|
||
403: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
/** @description An upload was accepted within the per-user cooldown window (submission_cooldown). */
|
||
429: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content?: never;
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
withdrawSubmission: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The withdrawn submission, as it was before the deletion. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Submission"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Submission has already been reviewed and cannot be withdrawn. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
patchServer: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
name: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description Trimmed. An empty name clears it, and the server goes by its name again. At most 64 characters, all visible ones or spaces (400 bad_display_name otherwise). */
|
||
displayName?: string;
|
||
autostartPolicy?: string;
|
||
/** @description Re-admitted against the whitelist (a pinned name:tag@sha256:… ref is admitted by its name:tag) and pinned like create does. A pin equal to the current image is no change; any other needs confirmImageChange. */
|
||
image?: string;
|
||
/** @description Acknowledges that the new image opens the world with its Minecraft version, whose chunk upgrades the old one cannot read. Without it an image that would move the server is refused with 409 image_change_unconfirmed. The audit row records image_from/image_to. */
|
||
confirmImageChange?: boolean;
|
||
/** @description Sets the memory limit and request together, as create does, and re-derives the JVM heap. The CPU limit and request are kept. */
|
||
memory?: string;
|
||
/** @description Rejected with 400 storage_immutable — present for a clear error, not mutation. */
|
||
storage?: string;
|
||
/** @description Single fields of the pod block, laid over what the server has: a field left out keeps its value, so each may be sent alone. An empty cpu or cpuRequest removes that limit or request; the memory ceiling cannot be emptied. A request above its limit is a 400. */
|
||
resources?: {
|
||
cpu?: string;
|
||
cpuRequest?: string;
|
||
memory?: string;
|
||
memoryRequest?: string;
|
||
};
|
||
/**
|
||
* Format: int32
|
||
* @description Idle auto-stop. 0 turns it off; otherwise the server stops after this many seconds with nobody online (60–86400, else 400 bad_idle_stop).
|
||
*/
|
||
idleStopSeconds?: number;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Patched. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
name: string;
|
||
patched: string[];
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
409: components["responses"]["Conflict"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
listBuilds: {
|
||
parameters: {
|
||
query?: {
|
||
/** @description Build id or status (exact), or part of the image ref; case-insensitive */
|
||
query?: string;
|
||
limit?: number;
|
||
offset?: number;
|
||
};
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description A page of builds plus how many match the query. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
builds: components["schemas"]["Build"][];
|
||
total: number;
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
buildImage: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description Push target under the internal registry (e.g. registry.felis.svc:5000/foo:1.0). */
|
||
image_ref: string;
|
||
/** @description Audit archive of the recipe, recorded on the build row and shown in the panel — the executed Dockerfile is the file named `Dockerfile` at the root of the context tarball (Kaniko runs --dockerfile=Dockerfile), so this field is never executed. */
|
||
dockerfile: string;
|
||
/** @description Location of the uploaded gzip build context; its root must contain the Dockerfile that gets executed. */
|
||
context_ref: string;
|
||
/** @description Resolved FROM, recorded for audit only — not a build gate. */
|
||
base_image?: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Build accepted. */
|
||
202: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Build"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
getBuild: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The build. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Build"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
buildLogs: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: {
|
||
/** @description The id of the last line received; resumes the stream from that second (within the hour). */
|
||
"Last-Event-ID"?: string;
|
||
};
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description An event stream of build log lines (`id:` + `data:` per line), ended by `event: revoked` when the caller is no longer staff. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"text/event-stream": string;
|
||
};
|
||
};
|
||
/** @description Malformed build id (bad_request). The id becomes a label-selector value, so it is refused before any lookup. */
|
||
400: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
cancelBuild: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The build after cancellation. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Build"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Build already terminal. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
getBuildScan: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The kept scan. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["BuildScan"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description No scan for this build (scan_not_found) — it has not reached the scan step, or it ran before builds kept their scans. */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
getBuildScanReport: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The Trivy report (SchemaVersion 2), served as the attachment <id>-trivy.json. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": Record<string, never>;
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description No scan for this build (scan_not_found), or the report was too large to keep (scan_document_not_kept). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
getBuildSBOM: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The CycloneDX JSON SBOM, served as the attachment <id>.cdx.json. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/vnd.cyclonedx+json": Record<string, never>;
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
/** @description No scan for this build (scan_not_found), or the SBOM was too large to keep or its step failed (scan_document_not_kept). */
|
||
404: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
listImages: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The image whitelist. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
images: components["schemas"]["Image"][];
|
||
};
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
addImage: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
image_ref: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description Image whitelisted. */
|
||
201: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Image"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
removeImage: {
|
||
parameters: {
|
||
query: {
|
||
ref: string;
|
||
};
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
204: components["responses"]["NoContent"];
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
listSubmissions: {
|
||
parameters: {
|
||
query?: {
|
||
status?: "pending_review" | "approved" | "rejected";
|
||
/** @description Part of the id, the submitter or the display name; case-insensitive */
|
||
query?: string;
|
||
limit?: number;
|
||
offset?: number;
|
||
};
|
||
header?: never;
|
||
path?: never;
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description One page of every user's submissions, newest first. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": {
|
||
submissions: components["schemas"]["Submission"][];
|
||
/** @description How many submissions match status and query in all. */
|
||
total: number;
|
||
/** @description How many of the scope's submissions sit in each status, whatever status and query say. */
|
||
counts: {
|
||
pending_review: number;
|
||
approved: number;
|
||
rejected: number;
|
||
};
|
||
};
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
approveSubmission: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
/** @description The context_sha256 the admin reviewed: the X-Felis-Context-Sha256 header of the context they downloaded, or the listed one. A context uploaded again since answers 409 context_changed. */
|
||
expected_digest: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The approved submission, with the linked build id. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Submission"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description The submission has already been reviewed (already_reviewed), or its context was uploaded again after the reviewed digest (context_changed). */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
downloadSubmissionContext: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The stored build context (gzip tarball), served as an attachment. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/gzip": string;
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
rejectSubmission: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody: {
|
||
content: {
|
||
"application/json": {
|
||
reason: string;
|
||
};
|
||
};
|
||
};
|
||
responses: {
|
||
/** @description The rejected submission. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Submission"];
|
||
};
|
||
};
|
||
400: components["responses"]["BadRequest"];
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
/** @description Submission has already been reviewed. */
|
||
409: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Error"];
|
||
};
|
||
};
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
deleteSubmission: {
|
||
parameters: {
|
||
query?: never;
|
||
header?: never;
|
||
path: {
|
||
id: string;
|
||
};
|
||
cookie?: never;
|
||
};
|
||
requestBody?: never;
|
||
responses: {
|
||
/** @description The deleted submission, as it was before the deletion. */
|
||
200: {
|
||
headers: {
|
||
[name: string]: unknown;
|
||
};
|
||
content: {
|
||
"application/json": components["schemas"]["Submission"];
|
||
};
|
||
};
|
||
401: components["responses"]["Unauthorized"];
|
||
403: components["responses"]["Forbidden"];
|
||
404: components["responses"]["NotFound"];
|
||
503: components["responses"]["ServiceUnavailable"];
|
||
};
|
||
};
|
||
}
|