@artifact-keeper/sdk 1.7.0 → 1.10.0

package/src/types.gen.ts

@@ -80,7 +80,7 @@ export type AddProjectMemberRequest = {
     actions: Array<string>;
     principal_id: string;
     /**
-     * "user" or "group".
+     * "user", "service_account" or "group".
      */
     principal_type: string;
 };
@@ -98,6 +98,13 @@ export type AdminUserResponse = {
     id: string;
     is_active: boolean;
     is_admin: boolean;
+    /**
+     * Whether this row is a service account rather than a person (#3634).
+     *
+     * `list_users` already read this column; it was dropped here, leaving
+     * clients no way to tell the two kinds of principal apart.
+     */
+    is_service_account: boolean;
     last_login_at?: string | null;
     must_change_password: boolean;
     username: string;
@@ -126,6 +133,10 @@ export type AffectedRepo = {
 export type AgeGateConfigResponse = {
     enabled: boolean;
     min_age_days: number;
+    /**
+     * Age-source mode: `upstream_publish_time` or `first_seen` (#2264).
+     */
+    mode: string;
     repository_key: string;
 };
 
@@ -169,11 +180,50 @@ export type AnnouncePeerRequest = {
 };
 
 export type ApiTokenCreatedResponse = {
+    /**
+     * When the token expires (`None` = never). Authoritative from the mint,
+     * including any expiration the instance policy applied (#3460).
+     */
+    expires_at?: string | null;
     id: string;
     name: string;
+    /**
+     * True when the instance token expiration policy shaped this mint
+     * (applied a default or enforced the permitted range).
+     */
+    policy_applied: boolean;
     token: string;
 };
 
+/**
+ * The API token expiration policy, as stored and as served by the admin API.
+ */
+export type ApiTokenExpiryPolicy = {
+    /**
+     * Whether service-account token mints are subject to the policy.
+     * Defaults to false: expiring the credential a pipeline runs on is an
+     * outage on a schedule, so it must be an explicit opt-in.
+     */
+    apply_to_service_accounts?: boolean;
+    /**
+     * Applied when an enforced request omits `expires_in_days`. `None`
+     * means such requests are rejected instead.
+     */
+    default_days?: number | null;
+    /**
+     * Maximum acceptable `expires_in_days` while enforcing (inclusive).
+     */
+    max_days: number;
+    /**
+     * Minimum acceptable `expires_in_days` while enforcing (inclusive).
+     */
+    min_days: number;
+    /**
+     * When false the policy is entirely inert (historical behaviour).
+     */
+    require_expiration: boolean;
+};
+
 export type ApiTokenListResponse = {
     items: Array<ApiTokenResponse>;
 };
@@ -398,6 +448,24 @@ export type ArtifactResponse = {
      */
     revision?: number | null;
     size_bytes: number;
+    /**
+     * Id of the user that uploaded this artifact (#3271), mirroring
+     * [`ArtifactVersionResponse::uploaded_by`] (#2397). Always serialized —
+     * `null` for anonymous/unknown uploads and for proxy-cached objects,
+     * which have no `artifacts` row — so the UI can rely on the key being
+     * present.
+     */
+    uploaded_by?: string | null;
+    /**
+     * Display name for [`Self::uploaded_by`], resolved server-side so the UI
+     * does not have to follow a bare UUID with an admin-only user lookup
+     * (#3271). `null` whenever `uploaded_by` is `null`, and also when the
+     * referenced user row no longer exists (a deleted account leaves the id
+     * on the artifact). Populated by the listing and per-artifact metadata
+     * endpoints; other responses that build an `ArtifactResponse` leave it
+     * unresolved.
+     */
+    uploaded_by_username?: string | null;
     version?: string | null;
     /**
      * Optional human tag recorded for this revision (from the
@@ -529,6 +597,26 @@ export type AuditLogListResponse = {
  * Authentication provider availability.
  */
 export type AuthConfig = {
+    /**
+     * Whether the verified-admin break-glass local login path is available
+     * (issue #2571). Unlike `local_login_enabled` — which only advertises
+     * the full local form on explicit `ALLOW_LOCAL_ADMIN_LOGIN=true` opt-in —
+     * this reflects the default #443 break-glass: with SSO enabled it is
+     * `true` unless the operator opted into strict SSO-only via
+     * `SSO_DISABLE_ADMIN_BREAK_GLASS`. Display-only: the login endpoint
+     * independently enforces the same policy
+     * (`api::handlers::auth::local_login_gate`), so this flag never grants
+     * access by itself.
+     *
+     * **Admin-only (#3489).** It answers "is there a local admin password
+     * path into this instance?", which is exactly the recon an anonymous
+     * attacker wants before probing `/api/v1/auth/login`, so it is omitted
+     * for anonymous and non-admin callers like the other security-posture
+     * fields. The login UI does not consume it — it decides whether to show
+     * the credentials form from `local_login_enabled`, and `?fallback=local`
+     * remains the admin recovery route.
+     */
+    admin_break_glass_enabled?: boolean | null;
     /**
      * Whether an LDAP directory is configured.
      */
@@ -549,6 +637,16 @@ export type AuthConfig = {
      * Whether an OIDC provider is configured.
      */
     oidc_enabled: boolean;
+    /**
+     * Whether the web UI should attempt silent SSO auto-login (an invisible
+     * OIDC `prompt=none` check-sso probe) when an OIDC provider is enabled.
+     * Kill switch: `OIDC_SILENT_SSO=false` (default `true`). Display-only:
+     * the flag only tells the frontend whether to *initiate* the silent
+     * attempt; the SSO endpoints enforce all authentication policy
+     * themselves, and anonymous visitors are never redirected to a visible
+     * IdP login page by the silent flow.
+     */
+    silent_sso_enabled: boolean;
     /**
      * Whether SAML SSO is configured (derived from the SSO admin settings in the DB,
      * but for this endpoint we report whether the OIDC issuer is set as a proxy).
@@ -556,6 +654,35 @@ export type AuthConfig = {
     sso_enabled: boolean;
 };
 
+/**
+ * Non-secret provider settings for an `aws_ecr` / `aws_codeartifact` upstream
+ * (#1559).
+ */
+export type AwsUpstreamAuthRequest = {
+    /**
+     * CodeArtifact only: domain name. Required for `aws_codeartifact`.
+     */
+    domain?: string | null;
+    /**
+     * CodeArtifact only: account id owning the domain. Defaults to the
+     * caller's account.
+     */
+    domain_owner?: string | null;
+    /**
+     * CodeArtifact only: requested token lifetime in seconds (0, or
+     * 900..=43200). Defaults to the AWS default of 12 hours.
+     */
+    duration_seconds?: number | null;
+    /**
+     * AWS region of the registry or domain, e.g. `us-east-1`.
+     */
+    region: string;
+    /**
+     * ECR only: registry (account) id, used to pin the upstream host.
+     */
+    registry_id?: string | null;
+};
+
 export type BackupListResponse = {
     items: Array<BackupResponse>;
     total: number;
@@ -575,6 +702,41 @@ export type BackupResponse = {
     type: string;
 };
 
+/**
+ * What this registry knows about a base image: filled in only when the
+ * reference names an image stored here (a local repository, or a remote
+ * repository's cache), otherwise `found: false` and the console falls back
+ * to guessing from the name.
+ */
+export type BaseImageInfo = {
+    architecture?: string | null;
+    digest?: string | null;
+    found: boolean;
+    /**
+     * Whether the image carries conda.
+     */
+    has_conda: boolean;
+    /**
+     * Whether the image carries pip (a `pip install` in its history or a
+     * Python image label).
+     */
+    has_pip: boolean;
+    os?: string | null;
+    /**
+     * `<repo>/<image>:<tag>` inside this registry, when found.
+     */
+    reference?: string | null;
+    /**
+     * apt | dnf | microdnf | yum | apk, from the image's build history and
+     * labels; absent when the image does not say.
+     */
+    system_manager?: string | null;
+    /**
+     * The user the base image runs as; the spec's `user` defaults to it.
+     */
+    user?: string | null;
+};
+
 /**
  * One downloader (or the anonymous bucket) of an affected artifact.
  */
@@ -613,6 +775,14 @@ export type BlastRadiusResponse = {
     downloaders: Array<BlastDownloader>;
     page: number;
     per_page: number;
+    /**
+     * Exposure through proxy-cached content (#3397).
+     */
+    proxy_exposure: ProxyBlastRadius;
+    /**
+     * **Hosted content only.** Every field here is artifact-keyed; see
+     * [`ProxyBlastRadius`] for proxy-cached exposure.
+     */
     summary: BlastRadiusSummary;
     target: BlastRadiusTargetInfo;
     /**
@@ -925,9 +1095,20 @@ export type CiOidcToggleRequest = {
 
 export type CiTokenRequest = {
     /**
-     * UUID of the `ci_oidc_providers` row to use for validation.
+     * Optional UUID of the `ci_oidc_providers` row to validate against.
+     *
+     * Leave it out — and omit the body entirely — to have the provider
+     * resolved from the assertion's own `iss` claim (#3548). The UUID is
+     * server-generated and only published by the admin-only
+     * `GET /api/v1/admin/ci-oidc`, so requiring it here meant a keyless CI
+     * job had to authenticate with the admin password first.
+     *
+     * It is still honoured as an explicit override, for callers written
+     * against the pre-#3548 shape and for instances that configure two
+     * enabled providers on the same issuer. It must agree with the
+     * assertion's `iss`; a provider that does not is a 400.
      */
-    provider_id: string;
+    provider_id?: string | null;
 };
 
 export type CiTokenResponse = {
@@ -1066,8 +1247,18 @@ export type CreateApiTokenRequest = {
  * Create API token response
  */
 export type CreateApiTokenResponse = {
+    /**
+     * When the token expires (`None` = never). Authoritative from the mint,
+     * including any expiration the instance policy applied (#3460).
+     */
+    expires_at?: string | null;
     id: string;
     name: string;
+    /**
+     * True when the instance token expiration policy shaped this mint
+     * (applied a default or enforced the permitted range).
+     */
+    policy_applied: boolean;
     token: string;
 };
 
@@ -1185,6 +1376,18 @@ export type CreateGroupRequest = {
     name: string;
 };
 
+export type CreateImageBuildRequest = {
+    /**
+     * Image path within the repository (`team/app`).
+     */
+    image: string;
+    spec: ImageBuildSpec;
+    /**
+     * Tag to push (`2.56.0-genomics`).
+     */
+    tag: string;
+};
+
 export type CreateInstanceRequest = {
     api_key: string;
     name: string;
@@ -1256,6 +1459,12 @@ export type CreateMigrationRequest = {
 };
 
 export type CreateOidcConfigRequest = {
+    /**
+     * IdP group whose members are granted the admin role on login.
+     * Persisted as `attribute_mapping.admin_group`, the key the OIDC
+     * callback reads for admin elevation (#3420).
+     */
+    admin_group?: string | null;
     /**
      * Opt-in compatibility flag (migration 144): when `true` the provider
      * accepts ID tokens signed with RSA keys shorter than 2048 bits via a
@@ -1342,8 +1551,18 @@ export type CreateRepoTokenRequest = {
  * contains the plaintext value and is only shown once.
  */
 export type CreateRepoTokenResponse = {
+    /**
+     * When the token expires (`None` = never). Authoritative from the mint,
+     * including any expiration the instance policy applied (#3460).
+     */
+    expires_at?: string | null;
     id: string;
     name: string;
+    /**
+     * True when the instance token expiration policy shaped this mint
+     * (applied a default or enforced the permitted range).
+     */
+    policy_applied: boolean;
     repository_key: string;
     /**
      * The full token value (only returned at creation time).
@@ -1456,7 +1675,7 @@ export type CreateRepositoryRequest = {
      * - Any other non-empty string — custom index prefix.
      *
      * Stored in `repository_config` under `pypi_upstream_index_path`.
-     * Only meaningful for PyPI / Poetry / Conda Remote repositories.
+     * Only meaningful for PyPI / Poetry / Jupyter / Conda Remote repositories.
      */
     pypi_upstream_index_path?: string | null;
     quota_bytes?: number | null;
@@ -1531,6 +1750,13 @@ export type CreateSamlConfigRequest = {
     require_signed_assertions?: boolean | null;
     sign_requests?: boolean | null;
     slo_url?: string | null;
+    /**
+     * Optional URL-safe alias for the public SAML routes (#2583). Must
+     * match `^[a-z0-9][a-z0-9_-]*$`, be at most 64 characters, not look
+     * like a UUID, and be unique across SAML configurations. Omit it to
+     * keep the configuration addressable by its `id` only.
+     */
+    slug?: string | null;
     sp_entity_id?: string | null;
     sso_url: string;
     /**
@@ -1671,8 +1897,18 @@ export type CreateTokenRequest = {
 };
 
 export type CreateTokenResponse = {
+    /**
+     * When the token expires (`None` = never). Service-account tokens are
+     * exempt from the instance expiration policy unless the admin opted them
+     * in (`apply_to_service_accounts`) (#3460).
+     */
+    expires_at?: string | null;
     id: string;
     name: string;
+    /**
+     * True when the instance token expiration policy shaped this mint.
+     */
+    policy_applied: boolean;
     token: string;
 };
 
@@ -1735,17 +1971,6 @@ export type CreatedGroupRow = {
     updated_at: string;
 };
 
-export type CreatedPermissionRow = {
-    actions: Array<string>;
-    created_at: string;
-    id: string;
-    principal_id: string;
-    principal_type: string;
-    target_id: string;
-    target_type: string;
-    updated_at: string;
-};
-
 export type CurationCreateRuleRequest = {
     action: string;
     architecture?: string;
@@ -1782,6 +2007,19 @@ export type CurationCreateRuleRequest = {
 
 export type CurationPackageResponse = {
     architecture?: string | null;
+    attestation_error?: string | null;
+    attestation_identity?: string | null;
+    attestation_issuer?: string | null;
+    attestation_owner?: string | null;
+    /**
+     * Attestation verification record (#2955, surfaced by #3230):
+     * `unverified` | `verified` | `failed`, with the certificate-bound identity
+     * on success and the specific failing check otherwise. Without these an
+     * operator cannot answer "which packages verified, and against which
+     * certificate identity" without querying the database directly.
+     */
+    attestation_state: string;
+    attestation_verified_at?: string | null;
     checksum_sha256?: string | null;
     evaluated_at?: string | null;
     evaluated_by?: string | null;
@@ -2422,6 +2660,60 @@ export type DtVulnerability = {
     vulnId: string;
 };
 
+/**
+ * Per-repository egress proxy settings (#2469, #2811).
+ *
+ * `proxy_url` is **write-only**: it is encrypted at rest and never returned.
+ * [`EgressProxyResponse`] echoes a redacted form (`http:/***@proxy:3128`)
+ * so an operator can confirm the host and port without recovering the
+ * credentials, exactly as `upstream_auth_configured` does for upstream
+ * credentials.
+ */
+export type EgressProxyRequest = {
+    /**
+     * `inherit` (follow the process `HTTP_PROXY`/`HTTPS_PROXY`/`NO_PROXY`
+     * environment — the default), `direct` (never proxy this repository, even
+     * when the environment sets one), or `explicit` (use `proxy_url`, ignoring
+     * the environment entirely).
+     */
+    mode: string;
+    /**
+     * Comma-separated hosts / domain suffixes / CIDRs that bypass the proxy
+     * for this repository. Only meaningful when `mode` is `explicit`.
+     */
+    no_proxy?: string | null;
+    /**
+     * Proxy endpoint, `scheme://host[:port]`, http or https. May embed
+     * `user:pass@` credentials. Required when `mode` is `explicit`.
+     * Write-only, never returned in responses.
+     */
+    proxy_url?: string | null;
+};
+
+/**
+ * Read-back of a repository's egress-proxy settings. Carries no secret.
+ */
+export type EgressProxyResponse = {
+    /**
+     * `inherit`, `direct` or `explicit`.
+     */
+    mode: string;
+    /**
+     * The configured bypass list, if any.
+     */
+    no_proxy?: string | null;
+    /**
+     * Whether the configured proxy URL carries credentials. The credentials
+     * themselves are never returned.
+     */
+    proxy_credentials_configured: boolean;
+    /**
+     * The configured proxy with any credentials replaced by `***`. `None`
+     * unless `mode` is `explicit`.
+     */
+    proxy_url?: string | null;
+};
+
 export type EmailSubscriptionListResponse = {
     subscriptions: Array<EmailSubscriptionResponse>;
 };
@@ -2472,6 +2764,37 @@ export type ExchangeCodeResponse = {
     token_type: string;
 };
 
+/**
+ * One finding as an external scanner reports it.
+ *
+ * Deliberately the wire shape of [`FindingResponse`] minus the fields the
+ * server owns (ids, acknowledgment state, timestamps), so a scanner that can
+ * read AK's findings can post findings back in the same vocabulary.
+ */
+export type ExternalFindingInput = {
+    affected_component?: string | null;
+    affected_version?: string | null;
+    cve_id?: string | null;
+    description?: string | null;
+    fixed_version?: string | null;
+    /**
+     * Scanner severity token. Normalized through the shared classifier, so a
+     * vendor's own spelling (`Moderate`, `NEGLIGIBLE`, ...) is accepted.
+     *
+     * An UNRECOGNIZED token classifies as `high`, not `info` — fail-closed,
+     * per #3306. An unknown verdict from an unknown scanner is the one case
+     * where guessing low would silently disarm every gate that reads severity.
+     */
+    severity: string;
+    /**
+     * Vendor identity for this finding. Defaults to the submission's
+     * `scanner` when omitted, and is what `?source=` filters on (#3410).
+     */
+    source?: string | null;
+    source_url?: string | null;
+    title: string;
+};
+
 export type FacetValue = {
     count: number;
     value: string;
@@ -2656,6 +2979,18 @@ export type GroupRow = {
 
 /**
  * Growth summary for a time range.
+ *
+ * Computed from `storage_metrics` daily snapshots. **Accounting-basis note
+ * (#3249):** snapshots taken before the #3134/#3249 fix summed
+ * `artifacts.size_bytes` only, missing OCI layer/config blob bytes
+ * (`oci_blobs`) and proxy-cached bytes (`proxy_cache_artifacts`) while
+ * counting legacy backfilled `proxy-cache/%` rows. Those historical rows are
+ * deliberately left as recorded — the source tables hold no history, so past
+ * values cannot be recomputed, only fabricated. A growth series that spans
+ * the fix date therefore shows a one-day upward step in
+ * `storage_bytes_start/end` / `storage_growth_bytes` /
+ * `storage_growth_percent` when the corrected accounting first lands; it is
+ * a measurement correction, not real growth.
  */
 export type GrowthSummary = {
     artifacts_added: number;
@@ -2711,75 +3046,324 @@ export type IdentityResponse = {
     peer_id: string;
 };
 
-export type InitTransferBody = {
-    artifact_id: string;
-    chunk_size?: number | null;
+export type ImageBuildListResponse = {
+    items: Array<ImageBuildResponse>;
+    total: number;
 };
 
-/**
- * Request to install a plugin from Git
- */
-export type InstallFromGitRequest = {
+export type ImageBuildResponse = {
+    containerfile: string;
+    created_at: string;
+    digest?: string | null;
+    error?: string | null;
+    finished_at?: string | null;
+    id: string;
+    image: string;
+    log_bytes: number;
     /**
-     * Git ref (tag, branch, or commit)
+     * `<repo key>/<image>:<tag>` — the reference within this registry.
      */
-    ref?: string | null;
+    reference: string;
+    repository_key: string;
+    requested_by: string;
+    spec: unknown;
+    started_at?: string | null;
     /**
-     * Git repository URL
+     * queued | running | succeeded | failed
      */
-    url: string;
+    status: string;
+    tag: string;
 };
 
-/**
- * Request for installing from local file path
- */
-export type InstallFromLocalRequest = {
+export type ImageBuildSettingsResponse = {
     /**
-     * Local filesystem path to plugin directory
+     * Building is restricted to administrators on this instance.
      */
-    path: string;
-};
-
-export type InvalidateCacheQuery = {
+    admin_only: boolean;
     /**
-     * Artifact path to evict from the proxy cache. Same shape as the path
-     * segment of `GET /api/v1/repositories/{key}/artifacts/{path}`.
-     * Path-traversal segments such as `..` are rejected by
-     * `ProxyService::cache_storage_key` (covered by
-     * `test_invalidate_cache_by_key_rejects_invalid_path`).
+     * Whole-Dockerfile specs are accepted on this instance.
      */
-    path: string;
+    allow_dockerfile: boolean;
+    allow_run: boolean;
+    base_allowlist: Array<string>;
+    /**
+     * Whether the caller may build here: repository write access, plus
+     * admin when `admin_only`.
+     */
+    caller_may_build: boolean;
+    /**
+     * False when `AK_BUILDKIT_ADDR` / `AK_IMAGE_BUILD_PUSH_REGISTRY` are unset.
+     */
+    enabled: boolean;
+    max_concurrent: number;
+    /**
+     * The pip index every generated `pip install` uses, when configured.
+     */
+    pip_index_url?: string | null;
+    /**
+     * The address buildkitd pushes to, for display.
+     */
+    push_registry?: string | null;
+    /**
+     * Whether this repository can receive builds (local container repo).
+     */
+    repository_buildable: boolean;
+    /**
+     * Package managers a spec may install with, for the UI's dropdown.
+     */
+    supported_package_managers: Array<string>;
+    timeout_secs: number;
 };
 
-export type InvalidateCacheResponse = {
-    invalidated: boolean;
-    path: string;
-    repository_key: string;
+/**
+ * What a user asks for. Either a structured spec (`base_image` plus
+ * package groups, env, labels, user, workdir) or, when the instance allows
+ * it, a whole `dockerfile` the server only checks and stamps.
+ */
+export type ImageBuildSpec = {
+    apt?: Array<string>;
+    /**
+     * The image to build on (`python:3.12-slim`); must match the
+     * administrator's base allowlist when one is configured. Ignored when
+     * `dockerfile` is set (its FROM lines are checked instead).
+     */
+    base_image?: string;
+    conda?: Array<string>;
+    conda_channels?: Array<string>;
+    /**
+     * A complete Dockerfile replacing the structured fields; accepted only
+     * when `AK_IMAGE_BUILD_ALLOW_DOCKERFILE=true`. Every FROM must match the
+     * base allowlist; the spec label is appended so inspection still knows
+     * what the image came from.
+     */
+    dockerfile?: string | null;
+    /**
+     * Environment variables baked into the image.
+     */
+    env?: {
+        [key: string]: string;
+    };
+    /**
+     * OCI labels baked into the image.
+     */
+    labels?: {
+        [key: string]: string;
+    };
+    /**
+     * Build pip groups in a separate stage and copy only the installed
+     * packages into the final image, so build tooling and caches never ship.
+     */
+    multistage?: boolean;
+    /**
+     * Install steps, rendered in order.
+     */
+    packages?: Array<PackageGroup>;
+    pip?: Array<string>;
+    /**
+     * Raw `RUN` lines. Refused unless `AK_IMAGE_BUILD_ALLOW_RUN=true`.
+     */
+    run?: Array<string>;
+    /**
+     * The user the image runs as (`app`, `1000`, `1000:100`). Required
+     * when any system package group is present (they install as root).
+     */
+    user?: string | null;
+    /**
+     * Working directory the image starts in.
+     */
+    workdir?: string | null;
 };
 
-export type IssueResponse = {
-    artifact_id: string;
-    category: string;
-    check_result_id: string;
-    created_at: string;
-    description?: string | null;
-    id: string;
-    is_suppressed: boolean;
-    location?: string | null;
-    severity: string;
-    suppressed_at?: string | null;
-    suppressed_by?: string | null;
-    suppressed_reason?: string | null;
-    title: string;
+export type ImageConfig = {
+    cmd: Array<string>;
+    entrypoint: Array<string>;
+    env: {
+        [key: string]: string;
+    };
+    exposed_ports: Array<string>;
+    labels: {
+        [key: string]: string;
+    };
+    user: string;
+    working_dir: string;
 };
 
-export type KeyListResponse = {
-    keys: Array<SigningKeyPublic>;
-    total: number;
+/**
+ * One `history` row of the image config: the instruction that produced a
+ * layer, joined to that layer when it produced one. This is the closest an
+ * image gets to its Dockerfile when no provenance attestation carries the
+ * real one.
+ */
+export type ImageHistoryEntry = {
+    comment?: string | null;
+    created?: string | null;
+    created_by: string;
+    empty_layer: boolean;
+    layer_digest?: string | null;
+    size_bytes?: number | null;
 };
 
-export type LabelEntrySchema = {
-    key: string;
+export type ImageInspect = {
+    config: ImageConfig;
+    /**
+     * Digest of the manifest the details describe (the platform manifest
+     * when `reference` resolved to an index).
+     */
+    digest: string;
+    history: Array<ImageHistoryEntry>;
+    /**
+     * Digest of the index the reference points at, when it is one.
+     */
+    index_digest?: string | null;
+    layers: Array<ImageLayer>;
+    platforms: Array<ImagePlatform>;
+    provenance?: null | ImageProvenance;
+    /**
+     * The reference that was inspected (`repo/image:tag`).
+     */
+    reference: string;
+    size_bytes: number;
+    /**
+     * Which producer filled the document: `registry` (read from storage).
+     */
+    source: string;
+};
+
+export type ImageLayer = {
+    digest: string;
+    media_type: string;
+    size_bytes: number;
+};
+
+export type ImagePlatform = {
+    architecture: string;
+    os: string;
+    variant?: string | null;
+};
+
+/**
+ * What a BuildKit SLSA provenance attestation says about how the image
+ * was built. `dockerfile` is present only for `mode=max` attestations,
+ * which embed the source; the image builder always emits those.
+ */
+export type ImageProvenance = {
+    attestation_digest: string;
+    build_type?: string | null;
+    builder_id?: string | null;
+    dockerfile?: string | null;
+    dockerfile_name?: string | null;
+    predicate_type?: string | null;
+};
+
+/**
+ * One external scanner's verdict on one artifact.
+ */
+export type IngestExternalFindingsRequest = {
+    /**
+     * The artifact these findings are about.
+     */
+    artifact_id: string;
+    /**
+     * The findings. May be empty — a clean verdict is a verdict, and it is
+     * what clears a previously-flagged artifact.
+     */
+    findings: Array<ExternalFindingInput>;
+    /**
+     * Vendor name, recorded as each finding's `source` unless the finding
+     * overrides it. Required: an unattributed verdict cannot be filtered,
+     * audited, or withdrawn.
+     */
+    scanner: string;
+    /**
+     * Vendor build/database version, recorded as `scan_results.scanner_version`.
+     */
+    scanner_version?: string | null;
+};
+
+export type IngestExternalFindingsResponse = {
+    artifact_id: string;
+    findings_ingested: number;
+    grade: string;
+    repository_id: string;
+    /**
+     * The `scan_results` row written, already `completed`.
+     */
+    scan_id: string;
+    /**
+     * Repository security score after `recalculate_score`.
+     */
+    score: number;
+};
+
+export type InitTransferBody = {
+    artifact_id: string;
+    chunk_size?: number | null;
+};
+
+/**
+ * Request to install a plugin from Git
+ */
+export type InstallFromGitRequest = {
+    /**
+     * Git ref (tag, branch, or commit)
+     */
+    ref?: string | null;
+    /**
+     * Git repository URL
+     */
+    url: string;
+};
+
+/**
+ * Request for installing from local file path
+ */
+export type InstallFromLocalRequest = {
+    /**
+     * Local filesystem path to plugin directory
+     */
+    path: string;
+};
+
+export type InvalidateCacheQuery = {
+    /**
+     * Artifact path to evict from the proxy cache. Same shape as the path
+     * segment of `GET /api/v1/repositories/{key}/artifacts/{path}`.
+     * Path-traversal segments such as `..` are rejected by
+     * `ProxyService::cache_storage_key` (covered by
+     * `test_invalidate_cache_by_key_rejects_invalid_path`).
+     */
+    path: string;
+};
+
+export type InvalidateCacheResponse = {
+    invalidated: boolean;
+    path: string;
+    repository_key: string;
+};
+
+export type IssueResponse = {
+    artifact_id: string;
+    category: string;
+    check_result_id: string;
+    created_at: string;
+    description?: string | null;
+    id: string;
+    is_suppressed: boolean;
+    location?: string | null;
+    severity: string;
+    suppressed_at?: string | null;
+    suppressed_by?: string | null;
+    suppressed_reason?: string | null;
+    title: string;
+};
+
+export type KeyListResponse = {
+    keys: Array<SigningKeyPublic>;
+    total: number;
+};
+
+export type LabelEntrySchema = {
+    key: string;
     value?: string;
 };
 
@@ -2842,6 +3426,78 @@ export type LdapTestResult = {
     success: boolean;
 };
 
+/**
+ * One repository's before/after in a ledger backfill (#3650).
+ */
+export type LedgerBackfillRepository = {
+    /**
+     * `artifacts` bytes, excluding soft-deleted rows and legacy
+     * `proxy-cache/%` keys — migration 182's `hosted_bytes` rule verbatim.
+     */
+    after_hosted_bytes: number;
+    /**
+     * `oci_blobs` bytes (every row counts; a `pending_delete_at` marker is
+     * not a deletion and does not change the figure).
+     */
+    after_oci_bytes: number;
+    /**
+     * `proxy_cache_artifacts` bytes (every row counts). A breakdown of
+     * `after_total_bytes`, not a disjoint bucket.
+     */
+    after_proxy_bytes: number;
+    /**
+     * Ledger total after the backfill: `hosted + proxy + oci`, the same sum
+     * `/admin/stats.total_storage_bytes` aggregates.
+     */
+    after_total_bytes: number;
+    /**
+     * Ledger total before the backfill, or `null` when the repository had no
+     * ledger row at all. A database restored from backup is the `null` case:
+     * the restore inserts `artifacts` / `oci_blobs` / `proxy_cache_artifacts`
+     * rows without firing migration 182's triggers, so no ledger row is ever
+     * written for them.
+     */
+    before_total_bytes?: number | null;
+    /**
+     * `after_total_bytes - before_total_bytes`, counting a missing row as 0.
+     */
+    drift_bytes: number;
+    repository_id: string;
+    repository_key: string;
+};
+
+/**
+ * Result of `POST /api/v1/admin/storage/ledger/backfill` (#3650).
+ */
+export type LedgerBackfillResponse = {
+    /**
+     * `/admin/stats.total_storage_bytes` as it reads after the backfill.
+     */
+    after_total_storage_bytes: number;
+    /**
+     * `/admin/stats.total_storage_bytes` as it read before the backfill.
+     */
+    before_total_storage_bytes: number;
+    /**
+     * Per-repository detail, ordered by repository key.
+     */
+    repositories: Array<LedgerBackfillRepository>;
+    repositories_checked: number;
+    /**
+     * Repositories whose ledger total changed.
+     */
+    repositories_repaired: number;
+    /**
+     * Repositories deleted between the scan and their recompute. Not an
+     * error — the ledger row went with them.
+     */
+    repositories_skipped: number;
+    /**
+     * Sum of the absolute per-repository corrections, in bytes.
+     */
+    total_drift_bytes: number;
+};
+
 /**
  * Result of license compliance check.
  */
@@ -3002,6 +3658,18 @@ export type ListSbomsQuery = {
 export type ListUsersQuery = {
     is_active?: boolean | null;
     is_admin?: boolean | null;
+    /**
+     * Filter on the service-account discriminator (#3634).
+     *
+     * Service accounts are rows in `users`, so an unfiltered listing mixes
+     * them in with people. A client building a principal picker for
+     * `POST /api/v1/permissions` must be able to exclude them: that endpoint's
+     * `validate_principal` requires `principal_type = "service_account"` for
+     * such a row and rejects it as `"user"`, so offering one under `user` is a
+     * guaranteed 400. `None` keeps the historical unfiltered behavior, which
+     * the audit actor filter and the group member picker both want.
+     */
+    is_service_account?: boolean | null;
     page?: number | null;
     per_page?: number | null;
     search?: string | null;
@@ -3025,6 +3693,18 @@ export type LoginResponse = {
     must_change_password: boolean;
     refresh_token: string;
     token_type: string;
+    /**
+     * Set when the 2FA enforcement policy (#2805) requires this user to enrol
+     * in TOTP before a session can be issued. `totp_token` then carries an
+     * *enrollment ticket* rather than a verification ticket: redeem it at
+     * `POST /auth/totp/enroll/setup` followed by
+     * `POST /auth/totp/enroll/complete`, which returns the real session.
+     *
+     * A client that does not understand this field sees no `access_token` and
+     * must not treat the response as a successful login. It is never set at the
+     * same time as `totp_required`.
+     */
+    totp_enrollment_required?: boolean | null;
     totp_required?: boolean | null;
     totp_token?: string | null;
 };
@@ -3360,6 +4040,19 @@ export type OidcConfigResponse = {
     updated_at: string;
 };
 
+/**
+ * One install step: which manager, which packages, and for conda which
+ * channels. Groups render in the order given.
+ */
+export type PackageGroup = {
+    /**
+     * conda channels (`conda-forge`, `bioconda`); conda groups only.
+     */
+    channels?: Array<string>;
+    manager: PackageManager;
+    packages?: Array<string>;
+};
+
 export type PackageListQuery = {
     limit?: number;
     offset?: number;
@@ -3372,6 +4065,14 @@ export type PackageListResponse = {
     pagination: Pagination;
 };
 
+/**
+ * A package manager a spec may install with. The system managers run as
+ * root in the final stage and need the spec to name the `user` the image
+ * runs as afterwards; `pip` moves to a builder stage when `multistage` is
+ * set; `conda` always installs in the final stage.
+ */
+export type PackageManager = 'apt' | 'dnf' | 'microdnf' | 'yum' | 'apk' | 'pip' | 'conda';
+
 export type PackageResponse = {
     created_at: string;
     description?: string | null;
@@ -3441,6 +4142,37 @@ export type PackageVersionsResponse = {
     versions: Array<PackageVersionResponse>;
 };
 
+/**
+ * Query parameters for `POST /api/v1/admin/packages/backfill`.
+ */
+export type PackagesBackfillQuery = {
+    /**
+     * Restrict the walk to one repository. Omit to walk every hosted
+     * repository in a catalog-eligible format.
+     */
+    repository_key?: string | null;
+};
+
+export type PackagesBackfillResponse = {
+    /**
+     * Rows whose upsert errored; the walk continues past them.
+     */
+    artifacts_failed: number;
+    /**
+     * Live artifact rows considered.
+     */
+    artifacts_scanned: number;
+    /**
+     * Rows with no derivable package coordinates (index/sidecar rows).
+     */
+    artifacts_skipped: number;
+    message: string;
+    /**
+     * Catalog upserts performed.
+     */
+    packages_registered: number;
+};
+
 /**
  * Pagination metadata for list responses.
  *
@@ -3676,7 +4408,19 @@ export type PluginType = 'format_handler' | 'storage_backend' | 'authentication'
 export type PolicyExecutionResult = {
     artifacts_matched: number;
     artifacts_removed: number;
+    /**
+     * Bytes actually reclaimed by this run. Always zero for a dry run.
+     */
     bytes_freed: number;
+    /**
+     * Bytes held by the `artifacts_matched` rows -- what a run *would*
+     * reclaim. Populated for a dry run as well as a live one, which is the
+     * whole point of a preview: `bytes_freed` is deliberately zero on a dry
+     * run (nothing was freed), so before this field a preview could report
+     * which artifacts it would delete but never how much space that was
+     * worth (#2024).
+     */
+    bytes_matched: number;
     dry_run: boolean;
     errors: Array<string>;
     policy_id: string;
@@ -3861,6 +4605,241 @@ export type PromotionRuleResponse = {
     updated_at: string;
 };
 
+/**
+ * Exposure through proxy-cached content, reported alongside the hosted
+ * numbers (#3397).
+ *
+ * `summary` above is computed over `scan_findings` joined to `artifacts` and
+ * `download_statistics` — all three artifact-keyed. Proxy-cached bytes have no
+ * `artifacts` row by design, and their downloads land in
+ * `proxy_download_statistics` keyed by `proxy_cache_id`, so the hosted numbers
+ * were not merely incomplete for proxy content: they were structurally
+ * incapable of being non-zero for it. A confident zero to a security question
+ * is worse than an error, so this block exists even when it is all zeros — an
+ * operator can then see that proxy content WAS searched.
+ *
+ * Attribution runs through `proxy_scan_findings` (#3395). Before that table
+ * existed there was no per-CVE detail for proxy content to attribute a
+ * download to, which is why #3397 depended on #3395.
+ */
+export type ProxyBlastRadius = {
+    /**
+     * Distinct proxy-cached digests carrying this CVE.
+     */
+    affected_digest_count: number;
+    /**
+     * Repositories whose proxy cache holds one of those digests.
+     */
+    affected_repo_count: number;
+    /**
+     * Whether any such pull was anonymous.
+     */
+    anonymous_download_present: boolean;
+    /**
+     * `included` | `not_applicable` — see the constants. Never omit this:
+     * it is what tells a reader whether a zero below means "searched, nothing
+     * found" or "not searched".
+     */
+    coverage: string;
+    /**
+     * Proxy download events of affected digests in the window.
+     */
+    download_count: number;
+    /**
+     * Distinct authenticated users who pulled one.
+     */
+    downloader_user_count: number;
+};
+
+/**
+ * A CVE-identified finding retained from an inline proxy scan so it can be
+ * persisted into `proxy_scan_findings` and answered back to an operator
+ * asking "which CVE blocked my build?" (#3395).
+ *
+ * Deliberately narrower than [`RawFinding`]: only the columns the digest-keyed
+ * table stores. `description`, `source` and `source_url` are dropped because
+ * they are scanner prose that would bloat a row written on every proxied
+ * download, and because none of them identify the vulnerability.
+ *
+ * `cve_id` is non-optional here while it is optional on [`RawFinding`]: a
+ * finding a scanner could not attach a CVE id to has nothing to look up, and
+ * the table's identity key is the CVE. Such findings are dropped on the way
+ * in — they still count toward `findings_count` on the verdict, which is
+ * computed from the raw list before this projection runs.
+ */
+export type ProxyFinding = {
+    /**
+     * Canonical vulnerability id, e.g. `CVE-2021-44228` or `GHSA-...`.
+     */
+    cve_id: string;
+    /**
+     * Version that resolves it, when the scanner reported one — the single
+     * most actionable field for an operator whose build was just blocked.
+     */
+    fixed_version?: string | null;
+    /**
+     * Component the vulnerability was matched against.
+     */
+    package_name?: string | null;
+    package_version?: string | null;
+    /**
+     * Lowercase severity token (`critical`/`high`/`medium`/`low`/`info`),
+     * matching the tokens stored on `proxy_scan_results.max_severity`.
+     */
+    severity: string;
+    title?: string | null;
+};
+
+export type ProxyRescanRequest = {
+    /**
+     * Cache path within this repository, e.g.
+     * `simple/click/click-8.0.0-py3-none-any.whl`. Path-keyed for the same
+     * cross-tenant reason the read endpoint is.
+     */
+    path: string;
+};
+
+export type ProxyRescanResponse = {
+    critical_count: number;
+    digest: string;
+    /**
+     * Per-CVE detail from this run, bounded to [`MAX_PROXY_FINDINGS`].
+     */
+    findings: Array<ProxyFinding>;
+    findings_count: number;
+    high_count: number;
+    low_count: number;
+    max_severity?: string | null;
+    medium_count: number;
+    /**
+     * Components cataloged and persisted, i.e. how much SBOM this rescan
+     * produced. Zero means the scanner reported no inventory for these bytes.
+     */
+    package_count: number;
+    path: string;
+    repository_key: string;
+    /**
+     * `clean` | `vulnerable` -- the verdict just recorded.
+     */
+    state: string;
+};
+
+export type ProxyScanEntry = {
+    cached_at: string;
+    critical_count?: number | null;
+    /**
+     * SHA-256 of the cached bytes; NULL while the row is `pending_ingest`.
+     */
+    digest?: string | null;
+    /**
+     * The CVEs behind the counts (#3395), most severe first and bounded to
+     * [`MAX_PROXY_FINDINGS`].
+     *
+     * Populated ONLY for a single-path (`?path=`) read, and only for a
+     * `vulnerable` entry. Two reasons it is absent from the paged listing:
+     * one query per row would make the list an N+1, and the listing is a
+     * per-repository overview whose job is to point at the entry to open.
+     *
+     * `None` (omitted) means "not requested at this granularity"; an empty
+     * vector means "requested, and this digest has no recorded detail" --
+     * which is the real state for anything cached before #3395 shipped. The
+     * two must stay distinguishable or a pre-#3395 artifact renders as having
+     * no CVEs, which reads as clean.
+     */
+    findings?: Array<ProxyFinding> | null;
+    findings_count?: number | null;
+    high_count?: number | null;
+    low_count?: number | null;
+    max_severity?: string | null;
+    medium_count?: number | null;
+    /**
+     * Set only when `state` is `not_scanned`.
+     */
+    not_scanned_reason?: string | null;
+    path: string;
+    /**
+     * Floored at this repository's own `cached_at` -- see the module note.
+     */
+    scanned_at?: string | null;
+    size_bytes: number;
+    /**
+     * `clean` | `vulnerable` | `not_scanned` | `pending_ingest`.
+     */
+    state: string;
+};
+
+/**
+ * Per-state counts over **distinct digests**, not paths: one repository can
+ * cache the same digest at many paths, and the UI label must say so.
+ */
+export type ProxyScanSummary = {
+    clean: number;
+    not_scanned: number;
+    /**
+     * Catalog rows whose `checksum_sha256` is still NULL. Counted as PATHS
+     * (they have no digest to dedupe on) and excluded from every other count.
+     */
+    pending_ingest: number;
+    /**
+     * Distinct digests cached by this repository. Equals
+     * `clean + vulnerable + not_scanned`.
+     */
+    total_digests: number;
+    vulnerable: number;
+};
+
+/**
+ * One stored `proxy_scan_results` row, as returned by the admin
+ * inspect/invalidate endpoints (#3244).
+ */
+export type ProxyScanVerdictItem = {
+    checksum_sha256: string;
+    critical_count: number;
+    findings_count: number;
+    high_count: number;
+    low_count: number;
+    max_severity?: string | null;
+    medium_count: number;
+    scan_type: string;
+    scanned_at: string;
+    scanner_version?: string | null;
+    verdict: string;
+};
+
+/**
+ * Response for the admin proxy-scan-verdict endpoints (#3244).
+ */
+export type ProxyScanVerdictListResponse = {
+    /**
+     * The normalized (bare-hex) digest the verdicts are keyed on.
+     */
+    digest: string;
+    verdicts: Array<ProxyScanVerdictItem>;
+};
+
+export type ProxyScansResponse = {
+    items: Array<ProxyScanEntry>;
+    page: number;
+    per_page: number;
+    /**
+     * `fail_open` | `fail_closed`. Lets `not_scanned` be read as "may have
+     * been served unscanned" versus "was withheld".
+     */
+    proxy_scan_action: string;
+    repository_key: string;
+    /**
+     * Enforcement context. Without it `vulnerable` is ambiguous: with
+     * scanning on it means pulls are blocked; with scanning off it means the
+     * artifact is served anyway and the verdict was recorded elsewhere.
+     */
+    scan_on_proxy: boolean;
+    summary?: null | ProxyScanSummary;
+    /**
+     * Catalog paths matching the query (paths, not digests).
+     */
+    total: number;
+};
+
 /**
  * Body for declaring that a locally-owned PyPI project tracks an upstream one.
  */
@@ -4020,6 +4999,15 @@ export type RemoveProjectMemberRequest = {
     principal_type: string;
 };
 
+export type RenderImageBuildRequest = {
+    spec: ImageBuildSpec;
+};
+
+export type RenderImageBuildResponse = {
+    containerfile: string;
+    warnings: Array<string>;
+};
+
 /**
  * Repository exposure descriptor echoed in the response.
  */
@@ -4244,6 +5232,16 @@ export type RepositoryStorageBreakdown = {
     download_count: number;
     format: string;
     last_upload_at?: string | null;
+    /**
+     * The proxy-cache half of `artifact_count` / `storage_bytes`, read from
+     * `proxy_cache_artifacts` (those rows never appear in `artifacts`, #1280).
+     * Disjoint from the hosted figures above, which exclude the legacy
+     * backfilled `proxy-cache/%` `artifacts` rows the same way
+     * `repository_usage_ledger.hosted_bytes` does (migration 182) — unlike
+     * `StorageSnapshot::proxy_storage_bytes`, which is a breakdown of a total
+     * that already contains it. Defaults to 0 on older payloads.
+     */
+    proxy_artifact_count?: number;
     /**
      * Downloads served by this repository's remote pull-through proxy
      * (`proxy_download_statistics`, #2537/#2704). Proxy-cached objects carry
@@ -4253,6 +5251,7 @@ export type RepositoryStorageBreakdown = {
      * unaffected; defaults to 0 when deserializing older payloads.
      */
     proxy_download_count?: number;
+    proxy_storage_bytes?: number;
     repository_id: string;
     repository_key: string;
     repository_name: string;
@@ -4269,6 +5268,12 @@ export type RepositoryStorageBreakdown = {
  *
  * Quota is unaffected: these numbers are accounting/visibility only and do NOT
  * change how the repository's storage quota is enforced (#2056 §7).
+ *
+ * Known bounded exclusion: OCI *manifest* JSON objects are not weighed. Their
+ * `artifacts.size_bytes` holds the aggregate image size, not the stored
+ * object, so counting it would double the layer bytes (#3286); no column holds
+ * the manifest's true size. Manifests are a few KB each, so every figure below
+ * under-reports by roughly that much per tag (#3618).
  */
 export type RepositoryStorageStatsResponse = {
     /**
@@ -4414,6 +5419,18 @@ export type ResetPasswordResponse = {
 };
 
 export type RestoreRequest = {
+    /**
+     * Accept an archive whose integrity cannot be established (#3373).
+     *
+     * A restore refuses an archive it cannot check: since #3373 every backup
+     * records its payload checksum on the `backups` row, outside the archive,
+     * and the archive's contents are verified against it before any row is
+     * ingested. Archives captured before that column existed fall back to the
+     * checksum in their own manifest; one carrying neither cannot be verified
+     * at all, and this flag is the deliberate, audited way to restore it
+     * anyway. It never waives a checksum that is present and does not match.
+     */
+    allow_unverified_archive?: boolean;
     restore_artifacts?: boolean | null;
     restore_database?: boolean | null;
     target_repository_id?: string | null;
@@ -4422,6 +5439,13 @@ export type RestoreRequest = {
 export type RestoreResponse = {
     artifacts_restored: number;
     errors: Array<string>;
+    /**
+     * What the archive's contents were checked against (#3373):
+     * `recorded` (the digest on the `backups` row, the strong case),
+     * `manifest` (the archive's own checksum -- detects corruption, not
+     * tampering), or `waived` (`allow_unverified_archive` was set).
+     */
+    integrity_anchor: string;
     tables_restored: Array<string>;
 };
 
@@ -4563,6 +5587,12 @@ export type SamlConfigResponse = {
     require_signed_assertions: boolean;
     sign_requests: boolean;
     slo_url?: string | null;
+    /**
+     * URL-safe alias the public SAML routes accept in place of `id`
+     * (migration 218, #2583). `None` when the configuration has not been
+     * given one; it is then addressable by `id` only.
+     */
+    slug?: string | null;
     sp_entity_id: string;
     sso_url: string;
     updated_at: string;
@@ -4599,6 +5629,12 @@ export type SbomResponse = {
 };
 
 export type ScanConfigResponse = {
+    /**
+     * Opt-in that makes `severity_threshold` enforced on the proxy/OCI
+     * inline scan gate (#3243/#3246). When false (default), the gate blocks
+     * on any finding above `info`. Hosted-artifact blocking remains
+     * configured via scan policies.
+     */
     block_on_policy_violation: boolean;
     created_at: string;
     id: string;
@@ -4611,6 +5647,11 @@ export type ScanConfigResponse = {
     scan_enabled: boolean;
     scan_on_proxy: boolean;
     scan_on_upload: boolean;
+    /**
+     * Severity floor for the inline proxy scan gate; live only when
+     * `block_on_policy_violation` is set (#3243/#3246). Findings at or above
+     * it block the pull.
+     */
     severity_threshold: string;
     updated_at: string;
 };
@@ -4991,12 +6032,23 @@ export type StatusCount = {
 
 /**
  * Request body for storage GC.
+ *
+ * `dry_run` is **required** and unknown fields are **rejected** (#3501): a
+ * live GC pass is irreversible (no tombstone, no restore path short of a
+ * backup), so an ambiguous request must fail loudly instead of selecting the
+ * destructive branch. Before this, `{}` and any typo'd key
+ * (`{"dryRun": true}`, `{"dry_Run": true}`) silently deserialized to
+ * `dry_run: false` and performed a real deletion. Callers now say which pass
+ * they mean: `{"dry_run": true}` to estimate, `{"dry_run": false}` to
+ * delete; anything else is refused with an error naming the missing or
+ * unknown field (axum's `Json` rejection, HTTP 422), and nothing is deleted.
  */
 export type StorageGcRequest = {
     /**
      * When true, report what would be deleted without actually deleting.
+     * Required: an absent field is a rejected request, never a live delete.
      */
-    dry_run?: boolean;
+    dry_run: boolean;
 };
 
 /**
@@ -5007,6 +6059,15 @@ export type StorageGcResult = {
     bytes_freed: number;
     dry_run: boolean;
     errors: Array<string>;
+    /**
+     * Orphaned row-less Maven flat objects this pass identified but left in
+     * place because the sweep is not opted in (`MAVEN_FLAT_GC_ENABLED`
+     * unset, #3431). Report-only: these objects and their attribution rows
+     * were NOT deleted and are not counted in `storage_keys_deleted`. Always
+     * `0` on a dry run (a dry run deletes nothing anyway) and when the sweep
+     * is enabled.
+     */
+    maven_flat_objects_gated?: number;
     storage_keys_deleted: number;
 };
 
@@ -5014,10 +6075,51 @@ export type StorageGcResult = {
  * A single day's storage metrics snapshot.
  */
 export type StorageSnapshot = {
+    /**
+     * Proxy-cached objects at snapshot time (migration 210). They carry no
+     * `artifacts` row (#1280), so this is disjoint from `total_artifacts`.
+     * 0 for snapshots taken before migration 210 and on older payloads.
+     */
+    proxy_artifact_count?: number;
+    /**
+     * Pull-through serves, recorded in `proxy_download_statistics` rather
+     * than `download_statistics`, so this is disjoint from `total_downloads`.
+     */
+    proxy_download_count?: number;
+    /**
+     * Bytes held by those objects — a *breakdown* of `total_storage_bytes`
+     * above, not a disjoint bucket: that total sums
+     * `repository_usage_ledger (hosted_bytes + proxy_bytes + oci_bytes)` and
+     * migration 182 defines `proxy_bytes` as exactly this sum, so the two
+     * must not be added. Same contract as the identically named
+     * `/admin/stats` field (#3134/#3249). (On `RepositoryStorageBreakdown`
+     * the same field name IS disjoint from that struct's `storage_bytes`,
+     * which is hosted-only.)
+     */
+    proxy_storage_bytes?: number;
     snapshot_date: string;
+    /**
+     * Rows in `artifacts` (for OCI repositories that is manifests only —
+     * layer/config blobs are content-addressed objects, not artifacts), the
+     * same deliberate decision as the dashboard's
+     * `SystemStats::total_artifacts` (#3134). Unlike the byte total, this
+     * count still includes legacy backfilled `proxy-cache/%` rows.
+     */
     total_artifacts: number;
     total_downloads: number;
     total_repositories: number;
+    /**
+     * All stored bytes at snapshot time, summed from
+     * `repository_usage_ledger` (`hosted_bytes + proxy_bytes + oci_bytes`) —
+     * the same source as the dashboard `total_storage_bytes` and quota
+     * admission (#3134/#3249), so the analytics series is consistent with
+     * both by construction. Includes OCI layer/config blob bytes
+     * (`oci_blobs`) and proxy-cached bytes (`proxy_cache_artifacts`);
+     * excludes legacy backfilled `proxy-cache/%` `artifacts` rows (their
+     * bytes are represented by the proxy-cache catalog instead). This is the
+     * LOGICAL figure: a blob cross-repo-mounted into N repositories counts
+     * once per repository, matching the per-repo storage column and quota.
+     */
     total_storage_bytes: number;
     total_users: number;
 };
@@ -5200,11 +6302,11 @@ export type SyncTriggerResponse = {
  * affordances a caller needs *before* authenticating (upload limit, demo
  * mode, whether guest access and which login providers are available).
  * * **Security-posture fields** (`scanners`, `search_engine`,
- * `storage_backend`, `permissions`, `plugin_signing`) describe the
- * instance's defensive configuration. They are returned **only to
- * authenticated admins** and are omitted for anonymous / non-admin callers,
- * so the deployment's security posture cannot be fingerprinted by an
- * unauthenticated attacker.
+ * `storage_backend`, `permissions`, `plugin_signing`, and
+ * `auth.admin_break_glass_enabled`) describe the instance's defensive
+ * configuration. They are returned **only to authenticated admins** and are
+ * omitted for anonymous / non-admin callers, so the deployment's security
+ * posture cannot be fingerprinted by an unauthenticated attacker.
  */
 export type SystemConfigResponse = {
     /**
@@ -5268,9 +6370,39 @@ export type SystemSettings = {
 export type SystemStats = {
     active_peers: number;
     pending_sync_tasks: number;
+    /**
+     * Count of proxy-cached (pull-through) objects, tracked in
+     * `proxy_cache_artifacts` rather than `artifacts`. This COUNT is disjoint
+     * from `total_artifacts`, which reads only the hosted tables.
+     */
+    proxy_artifact_count: number;
+    /**
+     * Bytes held by proxy-cached objects. Since #3134 this is a **breakdown
+     * of** `total_storage_bytes`, not a disjoint bucket: the ledger's
+     * `proxy_bytes` component is already inside that total, so a dashboard
+     * that adds the two double-counts the cache (#3650). The count above and
+     * the bytes here therefore do NOT compose the same way — only the count
+     * is disjoint.
+     */
+    proxy_storage_bytes: number;
+    /**
+     * Rows in `artifacts` (for OCI repositories that is manifests only —
+     * layer/config blobs are content-addressed objects, not artifacts).
+     * Unlike the byte total, this count still includes legacy backfilled
+     * `proxy-cache/%` rows.
+     */
     total_artifacts: number;
     total_downloads: number;
     total_repositories: number;
+    /**
+     * All stored bytes, summed from `repository_usage_ledger`
+     * (`hosted_bytes + proxy_bytes + oci_bytes`) — the same source the
+     * per-repository `storage_used_bytes` figures are read from, so the
+     * dashboard total is consistent with the per-repo column by
+     * construction (#3134). Includes OCI layer/config blob bytes
+     * (`oci_blobs`) and proxy-cached bytes; `proxy_storage_bytes` below is
+     * a *breakdown* of this total, not a disjoint bucket.
+     */
     total_storage_bytes: number;
     total_users: number;
 };
@@ -5360,35 +6492,172 @@ export type TokenInfoResponse = {
     last_used_at?: string | null;
     name: string;
     /**
-     * Dynamic repository selector, if configured.
+     * Dynamic repository selector, if configured.
+     */
+    repo_selector?: {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Explicit repository IDs this token is restricted to (from join table).
+     */
+    repository_ids: Array<string>;
+    scopes: Array<string>;
+    token_prefix: string;
+};
+
+export type TokenListResponse = {
+    items: Array<TokenInfoResponse>;
+};
+
+/**
+ * Current API token expiration policy plus the inventory an operator needs
+ * before (or after) tightening it: how many live tokens already exist with
+ * no expiration. Enabling the policy never touches those rows — they are
+ * surfaced here so an administrator can rotate them deliberately.
+ */
+export type TokenPolicyResponse = {
+    /**
+     * Whether `PUT` can change the policy at all right now.
+     */
+    editable: boolean;
+    /**
+     * Live never-expiring tokens held by service accounts (CI credentials —
+     * exempt from enforcement unless `apply_to_service_accounts` is set).
+     */
+    non_expiring_service_account_tokens: number;
+    /**
+     * Live (unrevoked, active-owner) never-expiring tokens held by regular
+     * users. These predate or bypass the policy and are unaffected by it;
+     * rotate them via the existing token-revocation endpoints.
+     */
+    non_expiring_user_tokens: number;
+    /**
+     * The policy in force.
+     */
+    policy: ApiTokenExpiryPolicy;
+    /**
+     * Whether it comes from the `API_TOKEN_EXPIRATION_*` environment
+     * variables (in which case `PUT` is refused) or from the database.
+     */
+    source: TokenPolicySource;
+};
+
+/**
+ * Where the effective policy came from, surfaced on the admin read endpoint
+ * so an operator can tell why a `PUT` is refused.
+ */
+export type TokenPolicySource = 'environment' | 'database';
+
+export type TotpCodeRequest = {
+    code: string;
+};
+
+export type TotpDisableRequest = {
+    code: string;
+    password: string;
+};
+
+export type TotpEnableResponse = {
+    backup_codes: Array<string>;
+};
+
+/**
+ * Request body completing forced enrollment.
+ */
+export type TotpEnrollCompleteRequest = {
+    /**
+     * The current 6-digit code from the authenticator that scanned the secret.
+     */
+    code: string;
+    /**
+     * The `totp_token` returned alongside `totp_enrollment_required: true`.
+     */
+    totp_token: string;
+};
+
+/**
+ * Successful forced enrollment: a real session *plus* the backup codes.
+ *
+ * The session is returned here, in the same response that completes
+ * enrollment, so a user subject to the policy is never left holding a valid
+ * password and no way in.
+ */
+export type TotpEnrollCompleteResponse = {
+    access_token: string;
+    /**
+     * One-time recovery codes. Shown exactly once — they are stored hashed.
+     */
+    backup_codes: Array<string>;
+    expires_in: number;
+    must_change_password: boolean;
+    refresh_token: string;
+    token_type: string;
+};
+
+/**
+ * Request body carrying an enrollment ticket issued by `POST /auth/login`.
+ */
+export type TotpEnrollSetupRequest = {
+    /**
+     * The `totp_token` returned alongside `totp_enrollment_required: true`.
+     */
+    totp_token: string;
+};
+
+/**
+ * System-wide 2FA enforcement policy.
+ */
+export type TotpPolicy = 'disabled' | 'required_for_admins' | 'required_for_all';
+
+/**
+ * Current 2FA enforcement policy plus the context an operator needs before
+ * tightening it.
+ */
+export type TotpPolicyResponse = {
+    /**
+     * Whether the *calling* administrator has TOTP enabled. Tightening the
+     * policy requires this.
+     */
+    caller_totp_enabled: boolean;
+    /**
+     * Whether `PUT` can change the policy at all right now.
+     */
+    editable: boolean;
+    /**
+     * Local (password-authenticating, non-service) administrators.
+     */
+    local_admins: number;
+    /**
+     * How many of those already have TOTP enabled. Under
+     * `required_for_admins`, `local_admins - local_admins_with_totp` is the
+     * number of administrators who will be sent through forced enrollment at
+     * their next sign-in.
+     */
+    local_admins_with_totp: number;
+    /**
+     * Local (password-authenticating, non-service) users, admins included.
      */
-    repo_selector?: {
-        [key: string]: unknown;
-    } | null;
+    local_users: number;
     /**
-     * Explicit repository IDs this token is restricted to (from join table).
+     * How many of those already have TOTP enabled.
      */
-    repository_ids: Array<string>;
-    scopes: Array<string>;
-    token_prefix: string;
-};
-
-export type TokenListResponse = {
-    items: Array<TokenInfoResponse>;
-};
-
-export type TotpCodeRequest = {
-    code: string;
-};
-
-export type TotpDisableRequest = {
-    code: string;
-    password: string;
+    local_users_with_totp: number;
+    /**
+     * The policy in force.
+     */
+    policy: TotpPolicy;
+    /**
+     * Whether it comes from the `TOTP_POLICY` environment variable (in which
+     * case `PUT` is refused) or from the database.
+     */
+    source: TotpPolicySource;
 };
 
-export type TotpEnableResponse = {
-    backup_codes: Array<string>;
-};
+/**
+ * Where the effective policy came from, surfaced on the admin read endpoint so
+ * an operator can tell why a `PUT` is refused.
+ */
+export type TotpPolicySource = 'environment' | 'database';
 
 export type TotpSetupResponse = {
     qr_code_url: string;
@@ -5492,6 +6761,11 @@ export type UninstallQuery = {
 export type UpdateAgeGateConfigRequest = {
     enabled: boolean;
     min_age_days: number;
+    /**
+     * Age-source mode. Omitted = keep the repository's current mode, so
+     * pre-mode clients that PUT `{enabled, min_age_days}` stay valid.
+     */
+    mode?: string | null;
 };
 
 export type UpdateAnalysisBody = {
@@ -5596,6 +6870,15 @@ export type UpdateLifecyclePolicyRequest = {
 };
 
 export type UpdateOidcConfigRequest = {
+    /**
+     * IdP group whose members are granted the admin role on login. `Some`
+     * sets `attribute_mapping.admin_group` after the mapping merge/replace
+     * above is applied; `None` leaves the mapping-derived value alone — so
+     * `None` together with `attribute_mapping_replace` clears it, which is
+     * how the env bootstrap revokes group-based admin when
+     * `OIDC_ADMIN_GROUP` is unset (#3420).
+     */
+    admin_group?: string | null;
     allow_legacy_rsa_keys?: boolean | null;
     /**
      * Partial update for `attribute_mapping`. Keys present in this object
@@ -5765,7 +7048,7 @@ export type UpdateRepositoryRequest = {
      * Update the PyPI simple-index prefix (stored in `repository_config` under
      * `pypi_upstream_index_path`). Pass `""` for flat CDN layout, `"simple"` to
      * restore the PEP 503 default, or any other non-empty string for a custom prefix.
-     * Only meaningful for PyPI / Poetry / Conda Remote repositories.
+     * Only meaningful for PyPI / Poetry / Jupyter / Conda Remote repositories.
      */
     pypi_upstream_index_path?: string | null;
     /**
@@ -5830,6 +7113,14 @@ export type UpdateSamlConfigRequest = {
     require_signed_assertions?: boolean | null;
     sign_requests?: boolean | null;
     slo_url?: string | null;
+    /**
+     * Set or change the URL-safe alias (#2583). Omitting it preserves the
+     * current value, matching how `slo_url` and `admin_group` behave; a
+     * slug therefore cannot be cleared through this endpoint, only
+     * replaced, so an ACS URL an IdP is already configured with cannot be
+     * removed by an update that simply forgot to mention it.
+     */
+    slug?: string | null;
     sp_entity_id?: string | null;
     sso_url?: string | null;
     use_absolute_acs_url?: boolean | null;
@@ -5865,6 +7156,20 @@ export type UpdateSyncPolicyPayload = {
     };
 };
 
+/**
+ * Request body for `PUT /admin/settings/token-policy`.
+ */
+export type UpdateTokenPolicyRequest = {
+    policy: ApiTokenExpiryPolicy;
+};
+
+/**
+ * Request body for `PUT /admin/settings/totp-policy`.
+ */
+export type UpdateTotpPolicyRequest = {
+    policy: TotpPolicy;
+};
+
 export type UpdateUserRequest = {
     display_name?: string | null;
     email?: string | null;
@@ -5872,7 +7177,22 @@ export type UpdateUserRequest = {
     is_admin?: boolean | null;
 };
 
+/**
+ * Full-set replace of a virtual repository's members (PR #2795, issue #2785;
+ * ratified in issue #2899).
+ *
+ * This body is the COMPLETE desired member list, not a partial patch. Any
+ * current member whose key is absent from `members` is removed; keys present
+ * are inserted or have their priority updated. An empty `members` array
+ * removes every member.
+ *
+ * WARNING: sending a partial list to reorder priorities deletes the omitted
+ * members. Clients must always send the full member list.
+ */
 export type UpdateVirtualMembersRequest = {
+    /**
+     * The complete desired member set. Members not listed here are removed.
+     */
     members: Array<VirtualMemberPriority>;
 };
 
@@ -5903,6 +7223,10 @@ export type UpsertLicensePolicyRequest = {
  * and an omitted field is never clobbered. See #1374 / B11.
  */
 export type UpsertScanConfigRequest = {
+    /**
+     * Opt-in that makes `severity_threshold` enforced on the proxy/OCI
+     * inline scan gate (#3243/#3246). Default false = block on any finding.
+     */
     block_on_policy_violation?: boolean | null;
     /**
      * #2954: `'fail_open'` (default) | `'fail_closed'` for the inline proxy
@@ -5912,14 +7236,20 @@ export type UpsertScanConfigRequest = {
     scan_enabled?: boolean | null;
     scan_on_proxy?: boolean | null;
     scan_on_upload?: boolean | null;
+    /**
+     * Severity floor for the inline proxy scan gate, live only when
+     * `block_on_policy_violation` is set (#3243/#3246).
+     */
     severity_threshold?: string | null;
 };
 
 export type UpstreamAuthRequest = {
     /**
-     * Auth type: "basic", "bearer", or "none" to remove.
+     * Auth type: "basic", "bearer", "aws_ecr", "aws_codeartifact", or "none"
+     * to remove.
      */
     auth_type: string;
+    aws?: null | AwsUpstreamAuthRequest;
     /**
      * Password (basic) or token (bearer). Write-only, never returned.
      */
@@ -5964,7 +7294,13 @@ export type VersionResponse = {
 };
 
 export type VirtualMemberPriority = {
+    /**
+     * Key of the member repository. Inserted if it is not already a member.
+     */
     member_key: string;
+    /**
+     * Resolution priority. Lower values are searched first.
+     */
     priority: number;
 };
 
@@ -6013,7 +7349,7 @@ export type WasmPluginResponse = {
 /**
  * Webhook event types
  */
-export type WebhookEvent = 'artifact_uploaded' | 'artifact_deleted' | 'repository_created' | 'repository_deleted' | 'user_created' | 'user_deleted' | 'build_started' | 'build_completed' | 'build_failed' | 'age_gate_queued' | 'age_gate_approved' | 'age_gate_rejected';
+export type WebhookEvent = 'artifact_uploaded' | 'artifact_deleted' | 'repository_created' | 'repository_deleted' | 'user_created' | 'user_deleted' | 'build_started' | 'build_completed' | 'build_failed' | 'age_gate_queued' | 'age_gate_approved' | 'age_gate_rejected' | 'age_gate_reopened';
 
 export type WebhookListResponse = {
     items: Array<WebhookResponse>;
@@ -6508,14 +7844,18 @@ export type ExecuteBackupErrors = {
      */
     404: unknown;
     /**
-     * Internal server error
+     * Another backup is already in progress
+     */
+    409: unknown;
+    /**
+     * The run could not be started or its outcome could not be recorded
      */
     500: unknown;
 };
 
 export type ExecuteBackupResponses = {
     /**
-     * Backup executed
+     * Backup run finished; `status` is `completed` or `failed` and `error_message` carries the cause of a failure
      */
     200: BackupResponse;
 };
@@ -6535,6 +7875,10 @@ export type RestoreBackupData = {
 };
 
 export type RestoreBackupErrors = {
+    /**
+     * Archive integrity could not be established, or an unsupported option was supplied
+     */
+    400: unknown;
     /**
      * Backup not found
      */
@@ -7431,6 +8775,115 @@ export type GetHealthLogResponses = {
 
 export type GetHealthLogResponse = GetHealthLogResponses[keyof GetHealthLogResponses];
 
+export type BackfillPackagesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Restrict the walk to one repository. Omit to walk every hosted
+         * repository in a catalog-eligible format.
+         */
+        repository_key?: string | null;
+    };
+    url: '/api/v1/admin/packages/backfill';
+};
+
+export type BackfillPackagesErrors = {
+    /**
+     * Admin privileges required
+     */
+    401: unknown;
+    /**
+     * Repository not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type BackfillPackagesResponses = {
+    /**
+     * Backfill completed
+     */
+    200: PackagesBackfillResponse;
+};
+
+export type BackfillPackagesResponse = BackfillPackagesResponses[keyof BackfillPackagesResponses];
+
+export type DeleteProxyScanVerdictsData = {
+    body?: never;
+    path: {
+        /**
+         * Content digest: `sha256:<64 hex>` or bare 64-hex
+         */
+        digest: string;
+    };
+    query?: never;
+    url: '/api/v1/admin/proxy-scan-verdicts/{digest}';
+};
+
+export type DeleteProxyScanVerdictsErrors = {
+    /**
+     * Malformed digest
+     */
+    400: unknown;
+    /**
+     * Admin privileges required
+     */
+    403: unknown;
+    /**
+     * No stored verdict for this digest
+     */
+    404: unknown;
+};
+
+export type DeleteProxyScanVerdictsResponses = {
+    /**
+     * Deleted verdict rows (re-assessment forced on next pull)
+     */
+    200: ProxyScanVerdictListResponse;
+};
+
+export type DeleteProxyScanVerdictsResponse = DeleteProxyScanVerdictsResponses[keyof DeleteProxyScanVerdictsResponses];
+
+export type GetProxyScanVerdictsData = {
+    body?: never;
+    path: {
+        /**
+         * Content digest: `sha256:<64 hex>` or bare 64-hex
+         */
+        digest: string;
+    };
+    query?: never;
+    url: '/api/v1/admin/proxy-scan-verdicts/{digest}';
+};
+
+export type GetProxyScanVerdictsErrors = {
+    /**
+     * Malformed digest
+     */
+    400: unknown;
+    /**
+     * Admin privileges required
+     */
+    403: unknown;
+    /**
+     * No stored verdict for this digest
+     */
+    404: unknown;
+};
+
+export type GetProxyScanVerdictsResponses = {
+    /**
+     * Stored verdict rows for the digest
+     */
+    200: ProxyScanVerdictListResponse;
+};
+
+export type GetProxyScanVerdictsResponse = GetProxyScanVerdictsResponses[keyof GetProxyScanVerdictsResponses];
+
 export type AdminListChecksData = {
     body?: never;
     path?: never;
@@ -7797,6 +9250,118 @@ export type UpdateSettingsResponses = {
 
 export type UpdateSettingsResponse = UpdateSettingsResponses[keyof UpdateSettingsResponses];
 
+export type GetTokenPolicyData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/admin/settings/token-policy';
+};
+
+export type GetTokenPolicyErrors = {
+    /**
+     * Admin privileges required
+     */
+    403: ErrorResponse;
+};
+
+export type GetTokenPolicyError = GetTokenPolicyErrors[keyof GetTokenPolicyErrors];
+
+export type GetTokenPolicyResponses = {
+    /**
+     * Current API token expiration policy
+     */
+    200: TokenPolicyResponse;
+};
+
+export type GetTokenPolicyResponse = GetTokenPolicyResponses[keyof GetTokenPolicyResponses];
+
+export type UpdateTokenPolicyData = {
+    body: UpdateTokenPolicyRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/admin/settings/token-policy';
+};
+
+export type UpdateTokenPolicyErrors = {
+    /**
+     * Inconsistent policy (range/default contradiction)
+     */
+    400: ErrorResponse;
+    /**
+     * Admin privileges required
+     */
+    403: ErrorResponse;
+    /**
+     * Refused: policy pinned by API_TOKEN_EXPIRATION_* environment variables
+     */
+    409: ErrorResponse;
+};
+
+export type UpdateTokenPolicyError = UpdateTokenPolicyErrors[keyof UpdateTokenPolicyErrors];
+
+export type UpdateTokenPolicyResponses = {
+    /**
+     * Policy updated
+     */
+    200: TokenPolicyResponse;
+};
+
+export type UpdateTokenPolicyResponse = UpdateTokenPolicyResponses[keyof UpdateTokenPolicyResponses];
+
+export type GetTotpPolicyData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/admin/settings/totp-policy';
+};
+
+export type GetTotpPolicyErrors = {
+    /**
+     * Admin privileges required
+     */
+    403: ErrorResponse;
+};
+
+export type GetTotpPolicyError = GetTotpPolicyErrors[keyof GetTotpPolicyErrors];
+
+export type GetTotpPolicyResponses = {
+    /**
+     * Current 2FA enforcement policy
+     */
+    200: TotpPolicyResponse;
+};
+
+export type GetTotpPolicyResponse = GetTotpPolicyResponses[keyof GetTotpPolicyResponses];
+
+export type UpdateTotpPolicyData = {
+    body: UpdateTotpPolicyRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/admin/settings/totp-policy';
+};
+
+export type UpdateTotpPolicyErrors = {
+    /**
+     * Admin privileges required
+     */
+    403: ErrorResponse;
+    /**
+     * Refused: policy pinned by TOTP_POLICY, or the calling admin has not enrolled in TOTP
+     */
+    409: ErrorResponse;
+};
+
+export type UpdateTotpPolicyError = UpdateTotpPolicyErrors[keyof UpdateTotpPolicyErrors];
+
+export type UpdateTotpPolicyResponses = {
+    /**
+     * Policy updated
+     */
+    200: TotpPolicyResponse;
+};
+
+export type UpdateTotpPolicyResponse = UpdateTotpPolicyResponses[keyof UpdateTotpPolicyResponses];
+
 export type SendTestEmailData = {
     body: SmtpTestRequest;
     path?: never;
@@ -8517,6 +10082,33 @@ export type OciBlobReportResponses = {
 
 export type OciBlobReportResponse = OciBlobReportResponses[keyof OciBlobReportResponses];
 
+export type BackfillStorageLedgerData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/admin/storage/ledger/backfill';
+};
+
+export type BackfillStorageLedgerErrors = {
+    /**
+     * Admin privileges required
+     */
+    401: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type BackfillStorageLedgerResponses = {
+    /**
+     * Ledger recomputed
+     */
+    200: LedgerBackfillResponse;
+};
+
+export type BackfillStorageLedgerResponse = BackfillStorageLedgerResponses[keyof BackfillStorageLedgerResponses];
+
 export type ListCrashesData = {
     body?: never;
     path?: never;
@@ -9052,6 +10644,9 @@ export type GetArtifactStatsResponses = {
 export type GetArtifactStatsResponse = GetArtifactStatsResponses[keyof GetArtifactStatsResponses];
 
 export type ExchangeCiTokenData = {
+    /**
+     * Optional. Omit the body entirely to resolve the provider from the assertion's iss claim; send provider_id only to override that.
+     */
     body: CiTokenRequest;
     path?: never;
     query?: never;
@@ -9059,12 +10654,16 @@ export type ExchangeCiTokenData = {
 };
 
 export type ExchangeCiTokenErrors = {
+    /**
+     * Malformed body, provider_id disagrees with the assertion's iss, or the issuer matches several enabled providers
+     */
+    400: ErrorResponse;
     /**
      * Invalid CI token or provider configuration
      */
     401: ErrorResponse;
     /**
-     * CI OIDC provider not found
+     * No enabled CI OIDC provider matches the assertion's issuer
      */
     404: ErrorResponse;
 };
@@ -9269,11 +10868,24 @@ export type OidcLoginData = {
          */
         id: string;
     };
-    query?: never;
+    query?: {
+        /**
+         * Optional OIDC `prompt` value forwarded to the IdP's authorization
+         * endpoint. Only `none` is accepted (silent check-sso): the web UI uses
+         * it to probe for an existing IdP session without ever rendering the
+         * IdP's login page. Any other value is rejected so the login redirect
+         * cannot be steered into unexpected IdP behaviours.
+         */
+        prompt?: string | null;
+    };
     url: '/api/v1/auth/sso/oidc/{id}/login';
 };
 
 export type OidcLoginErrors = {
+    /**
+     * Unsupported prompt value
+     */
+    400: ErrorResponse;
     /**
      * OIDC provider not found
      */
@@ -9302,7 +10914,7 @@ export type SamlAcsData = {
     body: SamlAcsForm;
     path: {
         /**
-         * SAML provider configuration ID
+         * SAML provider configuration ID (UUID) or slug
          */
         id: string;
     };
@@ -9323,7 +10935,7 @@ export type SamlLoginData = {
     body?: never;
     path: {
         /**
-         * SAML provider configuration ID
+         * SAML provider configuration ID (UUID) or slug
          */
         id: string;
     };
@@ -9438,6 +11050,10 @@ export type DisableTotpErrors = {
      * Invalid password or TOTP code
      */
     401: ErrorResponse;
+    /**
+     * The 2FA enforcement policy requires TOTP for this account
+     */
+    409: ErrorResponse;
 };
 
 export type DisableTotpError = DisableTotpErrors[keyof DisableTotpErrors];
@@ -9474,6 +11090,64 @@ export type EnableTotpResponses = {
 
 export type EnableTotpResponse = EnableTotpResponses[keyof EnableTotpResponses];
 
+export type EnrollCompleteData = {
+    body: TotpEnrollCompleteRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/totp/enroll/complete';
+};
+
+export type EnrollCompleteErrors = {
+    /**
+     * TOTP is already enabled, or /enroll/setup was not called first
+     */
+    400: ErrorResponse;
+    /**
+     * Invalid code, or invalid/expired/already-used enrollment ticket
+     */
+    401: ErrorResponse;
+};
+
+export type EnrollCompleteError = EnrollCompleteErrors[keyof EnrollCompleteErrors];
+
+export type EnrollCompleteResponses = {
+    /**
+     * TOTP enrolled; session and backup codes returned
+     */
+    200: TotpEnrollCompleteResponse;
+};
+
+export type EnrollCompleteResponse = EnrollCompleteResponses[keyof EnrollCompleteResponses];
+
+export type EnrollSetupData = {
+    body: TotpEnrollSetupRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/totp/enroll/setup';
+};
+
+export type EnrollSetupErrors = {
+    /**
+     * TOTP is already enabled for this account
+     */
+    400: ErrorResponse;
+    /**
+     * Invalid or expired enrollment ticket
+     */
+    401: ErrorResponse;
+};
+
+export type EnrollSetupError = EnrollSetupErrors[keyof EnrollSetupErrors];
+
+export type EnrollSetupResponses = {
+    /**
+     * TOTP secret and QR code URL for enrollment
+     */
+    200: TotpSetupResponse;
+};
+
+export type EnrollSetupResponse = EnrollSetupResponses[keyof EnrollSetupResponses];
+
 export type SetupTotpData = {
     body?: never;
     path?: never;
@@ -11416,7 +13090,14 @@ export type GetPackageData = {
          */
         id: string;
     };
-    query?: never;
+    query?: {
+        /**
+         * Optional repository key providing virtual-repo context. When it names a
+         * virtual repo that contains this package, the returned `repository_key`
+         * reports the virtual key (matching the aggregated listing).
+         */
+        repository_key?: string | null;
+    };
     url: '/api/v1/packages/{id}';
 };
 
@@ -12057,9 +13738,9 @@ export type GetAssignedReposErrors = {
 
 export type GetAssignedReposResponses = {
     /**
-     * List of assigned repository IDs
+     * Sync-enabled subscriptions for this peer (repo id + replication mode)
      */
-    200: Array<string>;
+    200: Array<SubscriptionResponse>;
 };
 
 export type GetAssignedReposResponse = GetAssignedReposResponses[keyof GetAssignedReposResponses];
@@ -14710,6 +16391,82 @@ export type DownloadArtifactResponses = {
 
 export type DownloadArtifactResponse = DownloadArtifactResponses[keyof DownloadArtifactResponses];
 
+export type GetEgressProxyData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/egress-proxy';
+};
+
+export type GetEgressProxyErrors = {
+    /**
+     * Authentication required
+     */
+    401: unknown;
+    /**
+     * Repository admin required
+     */
+    403: unknown;
+    /**
+     * Repository not found
+     */
+    404: unknown;
+};
+
+export type GetEgressProxyResponses = {
+    /**
+     * Egress proxy configuration
+     */
+    200: EgressProxyResponse;
+};
+
+export type GetEgressProxyResponse = GetEgressProxyResponses[keyof GetEgressProxyResponses];
+
+export type SetEgressProxyData = {
+    body: EgressProxyRequest;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/egress-proxy';
+};
+
+export type SetEgressProxyErrors = {
+    /**
+     * Invalid mode or proxy URL
+     */
+    400: unknown;
+    /**
+     * Authentication required
+     */
+    401: unknown;
+    /**
+     * Repository admin required
+     */
+    403: unknown;
+    /**
+     * Repository not found
+     */
+    404: unknown;
+};
+
+export type SetEgressProxyResponses = {
+    /**
+     * Egress proxy updated
+     */
+    200: EgressProxyResponse;
+};
+
+export type SetEgressProxyResponse = SetEgressProxyResponses[keyof SetEgressProxyResponses];
+
 export type ListSubscriptionsData = {
     body?: never;
     path: {
@@ -14772,21 +16529,218 @@ export type CreateSubscriptionErrors = {
      */
     403: unknown;
     /**
-     * Repository not found
+     * Repository not found
+     */
+    404: unknown;
+};
+
+export type CreateSubscriptionResponses = {
+    /**
+     * Subscription created
+     */
+    201: EmailSubscriptionResponse;
+};
+
+export type CreateSubscriptionResponse = CreateSubscriptionResponses[keyof CreateSubscriptionResponses];
+
+export type DeleteSubscriptionData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+        /**
+         * Subscription ID
+         */
+        subscription_id: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/email-subscriptions/{subscription_id}';
+};
+
+export type DeleteSubscriptionErrors = {
+    /**
+     * Not authenticated
+     */
+    401: unknown;
+    /**
+     * Insufficient permissions
+     */
+    403: unknown;
+    /**
+     * Subscription or repository not found
+     */
+    404: unknown;
+};
+
+export type DeleteSubscriptionResponses = {
+    /**
+     * Subscription deleted
+     */
+    204: void;
+};
+
+export type DeleteSubscriptionResponse = DeleteSubscriptionResponses[keyof DeleteSubscriptionResponses];
+
+export type ListImageBuildsData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/image-builds';
+};
+
+export type ListImageBuildsResponses = {
+    /**
+     * Builds, newest first
+     */
+    200: ImageBuildListResponse;
+};
+
+export type ListImageBuildsResponse = ListImageBuildsResponses[keyof ListImageBuildsResponses];
+
+export type CreateImageBuildData = {
+    body: CreateImageBuildRequest;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/image-builds';
+};
+
+export type CreateImageBuildErrors = {
+    /**
+     * Invalid spec, image name or tag; or the repository cannot receive builds
+     */
+    400: unknown;
+    /**
+     * Image builds are not configured on this instance
+     */
+    503: unknown;
+};
+
+export type CreateImageBuildResponses = {
+    /**
+     * Build queued
+     */
+    202: ImageBuildResponse;
+};
+
+export type CreateImageBuildResponse = CreateImageBuildResponses[keyof CreateImageBuildResponses];
+
+export type ImageBuildBaseInfoData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key (the one being built into)
+         */
+        key: string;
+    };
+    query: {
+        /**
+         * Base image reference as the spec names it
+         */
+        image: string;
+    };
+    url: '/api/v1/repositories/{key}/image-builds/base-info';
+};
+
+export type ImageBuildBaseInfoResponses = {
+    200: BaseImageInfo;
+};
+
+export type ImageBuildBaseInfoResponse = ImageBuildBaseInfoResponses[keyof ImageBuildBaseInfoResponses];
+
+export type RenderImageBuildData = {
+    body: RenderImageBuildRequest;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/image-builds/render';
+};
+
+export type RenderImageBuildErrors = {
+    /**
+     * The spec is invalid or refused by policy
+     */
+    400: unknown;
+};
+
+export type RenderImageBuildResponses = {
+    /**
+     * The Containerfile the server would build
+     */
+    200: RenderImageBuildResponse;
+};
+
+export type RenderImageBuildResponse2 = RenderImageBuildResponses[keyof RenderImageBuildResponses];
+
+export type ImageBuildSettingsData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/image-builds/settings';
+};
+
+export type ImageBuildSettingsResponses = {
+    /**
+     * Builder availability and policy
+     */
+    200: ImageBuildSettingsResponse;
+};
+
+export type ImageBuildSettingsResponse2 = ImageBuildSettingsResponses[keyof ImageBuildSettingsResponses];
+
+export type GetImageBuildData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+        /**
+         * Build id
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/image-builds/{id}';
+};
+
+export type GetImageBuildErrors = {
+    /**
+     * No such build
      */
     404: unknown;
 };
 
-export type CreateSubscriptionResponses = {
+export type GetImageBuildResponses = {
     /**
-     * Subscription created
+     * The build
      */
-    201: EmailSubscriptionResponse;
+    200: ImageBuildResponse;
 };
 
-export type CreateSubscriptionResponse = CreateSubscriptionResponses[keyof CreateSubscriptionResponses];
+export type GetImageBuildResponse = GetImageBuildResponses[keyof GetImageBuildResponses];
 
-export type DeleteSubscriptionData = {
+export type GetImageBuildLogData = {
     body?: never;
     path: {
         /**
@@ -14794,37 +16748,64 @@ export type DeleteSubscriptionData = {
          */
         key: string;
         /**
-         * Subscription ID
+         * Build id
          */
-        subscription_id: string;
+        id: string;
     };
     query?: never;
-    url: '/api/v1/repositories/{key}/email-subscriptions/{subscription_id}';
+    url: '/api/v1/repositories/{key}/image-builds/{id}/log';
 };
 
-export type DeleteSubscriptionErrors = {
+export type GetImageBuildLogErrors = {
     /**
-     * Not authenticated
+     * No such build
      */
-    401: unknown;
+    404: unknown;
+};
+
+export type GetImageBuildLogResponses = {
     /**
-     * Insufficient permissions
+     * The buildctl output so far, text/plain
      */
-    403: unknown;
+    200: unknown;
+};
+
+export type InspectImageData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query: {
+        /**
+         * Image path within the repository
+         */
+        image: string;
+        /**
+         * Tag or sha256: digest
+         */
+        reference: string;
+    };
+    url: '/api/v1/repositories/{key}/image-inspect';
+};
+
+export type InspectImageErrors = {
     /**
-     * Subscription or repository not found
+     * Repository, image or reference not found
      */
     404: unknown;
 };
 
-export type DeleteSubscriptionResponses = {
+export type InspectImageResponses = {
     /**
-     * Subscription deleted
+     * The image as its manifest, config and provenance describe it
      */
-    204: void;
+    200: ImageInspect;
 };
 
-export type DeleteSubscriptionResponse = DeleteSubscriptionResponses[keyof DeleteSubscriptionResponses];
+export type InspectImageResponse = InspectImageResponses[keyof InspectImageResponses];
 
 export type ListRepoLabelsData = {
     body?: never;
@@ -15422,6 +17403,95 @@ export type UpdateRepoSecurityResponses = {
 
 export type UpdateRepoSecurityResponse = UpdateRepoSecurityResponses[keyof UpdateRepoSecurityResponses];
 
+export type GetRepoProxyScansData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: {
+        /**
+         * Cache path of a single entry, e.g.
+         * `simple/click/click-8.0.0-py3-none-any.whl`. When set, the response
+         * carries just that entry and omits the repository summary.
+         */
+        path?: string | null;
+        page?: number | null;
+        per_page?: number | null;
+    };
+    url: '/api/v1/repositories/{key}/security/proxy-scans';
+};
+
+export type GetRepoProxyScansErrors = {
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Repository or path not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetRepoProxyScansError = GetRepoProxyScansErrors[keyof GetRepoProxyScansErrors];
+
+export type GetRepoProxyScansResponses = {
+    /**
+     * Proxy scan verdicts for a repository
+     */
+    200: ProxyScansResponse;
+};
+
+export type GetRepoProxyScansResponse = GetRepoProxyScansResponses[keyof GetRepoProxyScansResponses];
+
+export type RescanProxyCachedPathData = {
+    body: ProxyRescanRequest;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/security/proxy-scans/rescan';
+};
+
+export type RescanProxyCachedPathErrors = {
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Repository or path not found
+     */
+    404: ErrorResponse;
+    /**
+     * Cached object is above the inline scan cap
+     */
+    422: ErrorResponse;
+    /**
+     * Rescan cooldown in effect: `RESCAN_THROTTLED`, with `Retry-After` naming the remaining cooldown in whole seconds.
+     */
+    429: ErrorResponse;
+    /**
+     * Rescan could not produce a verdict: `NO_SCANNER_CONFIGURED` (no scanner is configured for this instance), `RESCAN_SCAN_FAILED` (the scan ran and errored), or `RESCAN_BUDGET_EXCEEDED` (the scan did not finish inside its budget). `Retry-After` is set only when cooldown time actually remains. The stored verdict is unchanged in every case.
+     */
+    503: ErrorResponse;
+};
+
+export type RescanProxyCachedPathError = RescanProxyCachedPathErrors[keyof RescanProxyCachedPathErrors];
+
+export type RescanProxyCachedPathResponses = {
+    /**
+     * Rescan completed
+     */
+    200: ProxyRescanResponse;
+};
+
+export type RescanProxyCachedPathResponse = RescanProxyCachedPathResponses[keyof RescanProxyCachedPathResponses];
+
 export type ListRepoScansData = {
     body?: never;
     path: {
@@ -15434,6 +17504,16 @@ export type ListRepoScansData = {
         repository_id?: string | null;
         artifact_id?: string | null;
         status?: string | null;
+        /**
+         * Restrict the listing to one scan engine (#3410), e.g. `grype`.
+         *
+         * `ScanResponse.scan_type` is already on the wire but could not be
+         * filtered on, so a deployment running several engines had to page the
+         * whole list and filter client-side. Validated against
+         * [`KNOWN_SCAN_TYPES`]: an unrecognized value is a `400`, never an
+         * unfiltered listing.
+         */
+        scan_type?: string | null;
         page?: number | null;
         per_page?: number | null;
     };
@@ -15486,6 +17566,38 @@ export type GetRepositoryStorageResponses = {
 
 export type GetRepositoryStorageResponse = GetRepositoryStorageResponses[keyof GetRepositoryStorageResponses];
 
+export type RunRepositoryStorageGcData = {
+    body: StorageGcRequest;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/storage-gc';
+};
+
+export type RunRepositoryStorageGcErrors = {
+    /**
+     * Authentication required, or admin privileges required
+     */
+    401: unknown;
+    /**
+     * Repository not found
+     */
+    404: unknown;
+};
+
+export type RunRepositoryStorageGcResponses = {
+    /**
+     * GC result
+     */
+    200: StorageGcResult;
+};
+
+export type RunRepositoryStorageGcResponse = RunRepositoryStorageGcResponses[keyof RunRepositoryStorageGcResponses];
+
 export type GetRepositoryStorageTreeData = {
     body?: never;
     path: {
@@ -16514,6 +18626,39 @@ export type GetDashboardResponses = {
 
 export type GetDashboardResponse = GetDashboardResponses[keyof GetDashboardResponses];
 
+export type IngestExternalFindingsData = {
+    body: IngestExternalFindingsRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/security/findings/external';
+};
+
+export type IngestExternalFindingsErrors = {
+    /**
+     * Malformed submission
+     */
+    400: ErrorResponse;
+    /**
+     * Admin privileges or the write:findings scope required
+     */
+    403: ErrorResponse;
+    /**
+     * Artifact not found
+     */
+    404: ErrorResponse;
+};
+
+export type IngestExternalFindingsError = IngestExternalFindingsErrors[keyof IngestExternalFindingsErrors];
+
+export type IngestExternalFindingsResponses = {
+    /**
+     * Findings ingested
+     */
+    200: IngestExternalFindingsResponse;
+};
+
+export type IngestExternalFindingsResponse2 = IngestExternalFindingsResponses[keyof IngestExternalFindingsResponses];
+
 export type RevokeAcknowledgmentData = {
     body?: never;
     path: {
@@ -16763,6 +18908,16 @@ export type ListScansData = {
         repository_id?: string | null;
         artifact_id?: string | null;
         status?: string | null;
+        /**
+         * Restrict the listing to one scan engine (#3410), e.g. `grype`.
+         *
+         * `ScanResponse.scan_type` is already on the wire but could not be
+         * filtered on, so a deployment running several engines had to page the
+         * whole list and filter client-side. Validated against
+         * [`KNOWN_SCAN_TYPES`]: an unrecognized value is a `400`, never an
+         * unfiltered listing.
+         */
+        scan_type?: string | null;
         page?: number | null;
         per_page?: number | null;
     };
@@ -16817,6 +18972,27 @@ export type ListFindingsData = {
         id: string;
     };
     query?: {
+        /**
+         * Restrict the listing to one severity (#3410).
+         *
+         * Validated against [`KNOWN_SEVERITIES`]; an unrecognized token is a
+         * `400` rather than an unfiltered page.
+         */
+        severity?: string | null;
+        /**
+         * Restrict the listing to findings written by one scanner (#3410).
+         *
+         * Matched exactly against `scan_findings.source`, which is already
+         * returned as `FindingResponse.source`. Free text (no closed vocabulary):
+         * bounded in length, not enumerated.
+         */
+        source?: string | null;
+        /**
+         * Restrict the listing to one vulnerability identifier (#3410).
+         *
+         * Matched exactly against `scan_findings.cve_id`.
+         */
+        cve_id?: string | null;
         page?: number | null;
         per_page?: number | null;
     };
@@ -18020,6 +20196,18 @@ export type ListUsersData = {
         search?: string | null;
         is_active?: boolean | null;
         is_admin?: boolean | null;
+        /**
+         * Filter on the service-account discriminator (#3634).
+         *
+         * Service accounts are rows in `users`, so an unfiltered listing mixes
+         * them in with people. A client building a principal picker for
+         * `POST /api/v1/permissions` must be able to exclude them: that endpoint's
+         * `validate_principal` requires `principal_type = "service_account"` for
+         * such a row and rejects it as `"user"`, so offering one under `user` is a
+         * guaranteed 400. `None` keeps the historical unfiltered behavior, which
+         * the audit actor filter and the group member picker both want.
+         */
+        is_service_account?: boolean | null;
         page?: number | null;
         per_page?: number | null;
     };
@@ -18382,7 +20570,7 @@ export type GetUserRolesData = {
 
 export type GetUserRolesResponses = {
     /**
-     * List of user roles
+     * List of user roles. The `permissions` array describes the ROLE's capabilities, not this user's effective repository access: roles listed here are identity/SSO-mapping metadata and grant no repository access on their own (#3387 / #3522).
      */
     200: RoleListResponse;
 };
@@ -18403,7 +20591,7 @@ export type AssignRoleData = {
 
 export type AssignRoleResponses = {
     /**
-     * Role assigned successfully
+     * Role assigned successfully. NOTE: roles assigned here are identity/SSO-mapping metadata and do NOT by themselves grant access to any repository — use POST /api/v1/permissions for that (#3387 / #3522).
      */
     200: unknown;
 };
@@ -18854,6 +21042,121 @@ export type LivenessCheckResponses = {
 
 export type LivenessCheckResponse = LivenessCheckResponses[keyof LivenessCheckResponses];
 
+export type XmlrpcData = {
+    /**
+     * XML-RPC `methodCall` (opaque). Supported methods: `browse([classifier, ...])` and `list_packages()`.
+     */
+    body: string;
+    path: {
+        /**
+         * Repository key
+         */
+        repo_key: string;
+    };
+    query?: never;
+    url: '/pypi/{repo_key}/pypi';
+};
+
+export type XmlrpcErrors = {
+    /**
+     * Repository not found
+     */
+    404: unknown;
+    /**
+     * Request body larger than 64 KiB
+     */
+    413: unknown;
+};
+
+export type XmlrpcResponses = {
+    /**
+     * XML-RPC `methodResponse` (opaque). `browse` answers `[[name, version], ...]` from stored metadata (hosted repositories, and the hosted members of a virtual); an unknown method, a malformed request, or either method on a remote repository or a virtual without hosted members (fault -32001: the call is never forwarded upstream; JupyterLab surfaces it as a generic error, the reason is in the response) answers an XML-RPC fault, not an HTTP error.
+     */
+    200: string;
+};
+
+export type XmlrpcResponse = XmlrpcResponses[keyof XmlrpcResponses];
+
+export type LegacyProjectJsonData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        repo_key: string;
+        /**
+         * Project name; normalized per PEP 503 for the lookup
+         */
+        project: string;
+    };
+    query?: never;
+    url: '/pypi/{repo_key}/pypi/{project}/json';
+};
+
+export type LegacyProjectJsonErrors = {
+    /**
+     * Project blocked by a curation rule
+     */
+    403: unknown;
+    /**
+     * Repository or project not found
+     */
+    404: unknown;
+};
+
+export type LegacyProjectJsonResponses = {
+    /**
+     * Legacy PyPI JSON document: `info` for the latest release, `releases` keyed by version, `urls` for the latest release. Download URLs point at this repository.
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+
+export type LegacyProjectJsonResponse = LegacyProjectJsonResponses[keyof LegacyProjectJsonResponses];
+
+export type LegacyReleaseJsonData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        repo_key: string;
+        /**
+         * Project name; normalized per PEP 503 for the lookup
+         */
+        project: string;
+        /**
+         * Release version (PEP 440; `1.0` matches a stored `1.0.0`)
+         */
+        version: string;
+    };
+    query?: never;
+    url: '/pypi/{repo_key}/pypi/{project}/{version}/json';
+};
+
+export type LegacyReleaseJsonErrors = {
+    /**
+     * Project or version blocked by a curation rule
+     */
+    403: unknown;
+    /**
+     * Repository, project or release not found
+     */
+    404: unknown;
+};
+
+export type LegacyReleaseJsonResponses = {
+    /**
+     * Legacy PyPI JSON document for one release: `info` and `urls`. Download URLs point at this repository.
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+
+export type LegacyReleaseJsonResponse = LegacyReleaseJsonResponses[keyof LegacyReleaseJsonResponses];
+
 export type ReadinessCheckData = {
     body?: never;
     path?: never;