The lq-ai contract & upstream loop

Donna implements no legal-AI logic — it consumes a contract. This is what happens when the contract isn't enough: file an ask, relay it, bump the pin.
src/lib/api/backend.d.ts12035 lines
Outline 5 symbolspaths interface export
webhooks type export
components interface export
$defs type export
operations type export
1/**
* This file was auto-generated by openapi-typescript.
* Do not make direct changes to the file.
*/
5
6export interface paths {
  "/api/v1/auth/login": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /** Authenticate with email and password */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["LoginRequest"];
              };
          };
          responses: {
              /** @description Authentication successful */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["LoginResponse"];
                  };
              };
              /** @description Invalid credentials */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description MFA required */
              423: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["MfaChallenge"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/auth/mfa/verify": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /** Complete MFA challenge with TOTP code */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      /** @description Token from the MFA challenge response */
                      mfa_token: string;
                      code: string;
                  };
              };
          };
          responses: {
              /** @description MFA verification successful */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["LoginResponse"];
                  };
              };
              /** @description Invalid MFA code */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/auth/refresh": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /** Refresh access token using refresh token */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      refresh_token: string;
                  };
              };
          };
          responses: {
              /** @description New access token issued */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TokenResponse"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/auth/logout": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /** Invalidate the current refresh token */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Logout successful */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/auth/mfa/setup": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Enroll in TOTP-based MFA
       * @description Bearer-authenticated. Issues a fresh TOTP secret, provisioning
       *     URI, and 10 single-use recovery codes. Persists the secret +
       *     bcrypt-hashed codes on the user, but does NOT enable MFA — the
       *     user must subsequently prove possession by submitting a TOTP
       *     code to `/auth/mfa/enable`. Re-running setup before enable
       *     overwrites the pending secret + codes; re-running after MFA is
       *     already enabled is a 409 (`mfa_already_enabled`).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description TOTP enrollment data (provisioning URI + recovery codes) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          secret: string;
                          /** @description otpauth:// URI for QR code */
                          provisioning_uri: string;
                          recovery_codes: string[];
                      };
                  };
              };
              /** @description MFA is already enabled (call `/auth/mfa/disable` first) */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/auth/mfa/enable": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Confirm TOTP enrollment with a verification code
       * @description Bearer-authenticated. Verifies a 6-digit TOTP code against the
       *     pending secret stored by `/auth/mfa/setup`. On success flips
       *     `users.mfa_enabled` to TRUE; subsequent logins for this user
       *     return 423 + `MfaChallenge`.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      code: string;
                  };
              };
          };
          responses: {
              /** @description MFA enabled */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Setup not started or code invalid */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description MFA is already enabled */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/auth/mfa/disable": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Disable MFA after re-proving password and a current MFA code
       * @description Bearer-authenticated. Requires both the user's current password
       *     AND a current TOTP code (or a single-use recovery code). On
       *     success clears the TOTP secret, recovery codes, and the
       *     `mfa_enabled` flag. Wrong-password and wrong-code branches both
       *     return 401 — the response shape does not reveal which leg
       *     failed.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      password: string;
                      code: string;
                  };
              };
          };
          responses: {
              /** @description MFA disabled */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description MFA is not enabled */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Invalid credentials or MFA code */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/auth/change-password": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Change the calling user's password
       * @description Bearer-authenticated. Verifies the current password before
       *     accepting a new one (defense against a stolen access token).
       *     Clears `must_change_password` if it was set (used by the
       *     first-run admin flow per Task B2). Revokes all active sessions
       *     for the user; the caller must re-authenticate.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["ChangePasswordRequest"];
              };
          };
          responses: {
              /** @description Password changed successfully */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description New password fails policy (too short */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Bearer token invalid or current_password is wrong */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /**
               * @description Reserved by the must-change-password gate elsewhere; the
               *     change-password endpoint itself is reachable while the gate
               *     is active.
               */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/users/me": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /** Get current user */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Current user */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["User"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      /**
       * Update the caller's own profile (display_name)
       * @description Bearer-authenticated. Caller-scoped — updates only the
       *     authenticated user's own row; no user id is accepted from the
       *     path or body. Currently edits `display_name` only: the value is
       *     trimmed, must be non-empty after trimming, and is length-capped
       *     (200 chars). Omitting `display_name` (or sending an empty body)
       *     is a 422 — there is nothing to update. Writes a
       *     `user.profile_updated` audit row listing the changed fields and
       *     returns the updated `User` (same shape as `GET /users/me`).
       *
       *     Email self-service editing is intentionally out of scope on this
       *     surface — changing the login email pulls in re-verification, MFA,
       *     and uniqueness concerns and warrants its own dedicated flow (a
       *     future enhancement).
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["UserProfileUpdate"];
              };
          };
          responses: {
              /** @description Updated user */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["User"];
                  };
              };
              /** @description Validation error (empty/whitespace/over-length display_name */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      trace?: never;
  };
  "/api/v1/users/me/export": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Request a per-user data export (GDPR Article 20)
       * @description Bearer-authenticated. Inserts a `user_export_jobs` row with
       *     status `queued` and enqueues the worker job that builds +
       *     uploads the ZIP. Returns 202 immediately — clients poll the
       *     per-job endpoint below for completion.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Export job queued */
              202: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /** Format: uuid */
                          job_id: string;
                          /** @enum {string} */
                          status: "queued" | "processing" | "completed" | "failed";
                          download_url?: string | null;
                      };
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/users/me/export/{job_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Poll a user-export job's status
       * @description Bearer-authenticated. Returns the current status of the export
       *     job. When `status=completed` and the bundle has not yet expired,
       *     `download_url` is a presigned MinIO URL valid for 24 hours. A
       *     404 covers both "no such job" and "job belongs to another user"
       *     (does not leak existence cross-user).
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  job_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Job status */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /** Format: uuid */
                          job_id: string;
                          /** @enum {string} */
                          status: "queued" | "processing" | "completed" | "failed";
                          download_url?: string | null;
                      };
                  };
              };
              /** @description Job not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/users/me/delete": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Request account deletion (GDPR Article 17)
       * @description Bearer-authenticated. Soft-schedules deletion: sets
       *     `users.deletion_scheduled_at = now() + gdpr_grace_period_days`,
       *     revokes all active sessions, and audit-logs the request. Login
       *     during the grace period is preserved so the user can call the
       *     cancel endpoint. Hard delete itself runs daily via a worker
       *     cron. Idempotent: re-calling returns the existing schedule
       *     rather than pushing it back.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Deletion queued */
              202: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /** Format: date-time */
                          scheduled_deletion_at: string;
                          grace_period_days: number;
                      };
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/users/me/delete/cancel": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Cancel a pending account deletion
       * @description Bearer-authenticated. Clears `deletion_scheduled_at` if a
       *     pending deletion exists; returns 400 if there is no pending
       *     deletion to cancel. Only valid during the grace-period window —
       *     once the hard-delete worker has run, there is no user row to
       *     recover.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Pending deletion cancelled */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description No pending deletion to cancel */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/users/me/preferences": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Read the caller's preferences (Wave A — PRD §3.2)
       * @description Returns the preferences slice of the user profile. The same
       *     fields appear on ``GET /users/me``; this dedicated endpoint
       *     exists so frontends can subscribe to preferences changes
       *     without re-fetching the whole user object.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Preferences snapshot */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["UserPreferences"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      /**
       * Update the caller's preferences (partial)
       * @description Only the fields the user supplies move. An idempotent PATCH
       *     (same value re-supplied) returns 200 without writing an audit
       *     row, matching the user_skills / saved_prompts pattern. Real
       *     changes write a ``user.preferences_updated`` audit row with
       *     before/after values in details.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["UserPreferencesUpdate"];
              };
          };
          responses: {
              /** @description Updated preferences */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["UserPreferences"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/enhance-prompt": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Expand a short prompt into a structured legal prompt
       * @description Invokes the ``enhance-prompt`` skill against the gateway (with
       *     ``lq_ai_skills=['enhance-prompt']`` so user/team-scope
       *     shadows of the skill are honored per the D8.1b resolver).
       *     Returns the structured expansion the SKILL.md output schema
       *     produces — ``expansion_applied`` + ``expanded_prompt`` +
       *     ``reasoning`` + ``skip_reason`` + ``preview_to_user`` — plus
       *     an ``interaction_id`` the frontend uses to PATCH ``used`` /
       *     ``edited_before_use`` after the user acts on the preview.
       *
       *     Defaults to the ``fast`` model alias (cheaper/smaller than
       *     ``smart`` per the spec's "smaller/cheaper model" guidance);
       *     ``model`` on the body overrides per-request.
       *
       *     When the model produces malformed structured output, the
       *     response carries ``expansion_applied=false`` +
       *     ``skip_reason='parse_error'`` rather than 500 — the frontend
       *     falls back to submitting the original prompt.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["EnhancePromptRequest"];
              };
          };
          responses: {
              /** @description Expansion (or a structured skip decision) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["EnhancePromptResponse"];
                  };
              };
              /** @description Gateway / provider failure during enhancement */
              502: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/enhance-prompt/{interaction_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              interaction_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      /**
       * Record what the user did with the enhancement preview
       * @description Updates ``used`` and ``edited_before_use`` for telemetry.
       *     Owner-only (404 if the row belongs to another user — same
       *     id-probing posture as user_skills + chats). Idempotent: a
       *     no-op PATCH returns 200 without writing.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  interaction_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["EnhancePromptOutcomeUpdate"];
              };
          };
          responses: {
              /** @description Updated interaction */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["EnhancePromptResponse"];
                  };
              };
              /** @description Interaction not found OR not owned by the caller. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/projects": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the caller's projects
       * @description Returns the caller's active projects by default. ``archived=true``
       *     returns archived projects only; ``archived=false`` is equivalent
       *     to omitting the parameter (active only). Per-user isolation:
       *     only the caller's own projects are returned.
       */
      get: {
          parameters: {
              query?: {
                  /** @description When true, return only archived projects. */
                  archived?: boolean;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description List of projects (active or archived per the filter). */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Project"][];
                  };
              };
          };
      };
      put?: never;
      /**
       * Create a project
       * @description Creates a project owned by the caller. ``slug`` is generated
       *     from ``name`` if omitted; collisions with the caller's existing
       *     active projects resolve with a numeric suffix (``-2``, ``-3``,
       *     ...). Setting ``privileged=true`` requires
       *     ``minimum_inference_tier`` to be set; missing-tier returns 422.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["ProjectCreate"];
              };
          };
          responses: {
              /** @description Project created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Project"];
                  };
              };
              /** @description Slug collision under concurrent create */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Schema validation failure (e.g., privileged-without-tier) */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/projects/{project_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              project_id: string;
          };
          cookie?: never;
      };
      /**
       * Fetch a single project
       * @description Returns the canonical ``Project`` shape with ``attached_file_ids``
       *     and ``attached_skill_names`` populated from the join tables.
       *     Archived projects are visible via direct GET so the client can
       *     render an archived-detail page; the list endpoint excludes them
       *     by default.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  project_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Project */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Project"];
                  };
              };
              /** @description Not found (or owned by another user) */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      /**
       * Soft-delete (archive) a project
       * @description Sets ``archived_at`` on the row. Hard-delete is owned by D6.
       *     Idempotent: a second DELETE on an already-archived project
       *     returns 404.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  project_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Project archived */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not found, or already archived */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      /**
       * Partial update of a project
       * @description Applies only the fields the caller sets. The
       *     ``privileged``↔``minimum_inference_tier`` rule is re-checked
       *     against the *merged* state — setting either alone in a way that
       *     would leave the project privileged-but-tierless returns 400.
       *     ``archived: true`` archives the project (equivalent to DELETE);
       *     ``archived: false`` unarchives it.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  project_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["ProjectUpdate"];
              };
          };
          responses: {
              /** @description Project updated */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Project"];
                  };
              };
              /** @description Cross-field rule violation (e.g., privileged-without-tier) */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Not found (or owned by another user) */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/projects/{project_id}/skills": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              project_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Attach a skill to the project
       * @description Attaches a registry-known skill to the project by name. The
       *     skill must exist in the in-memory skill registry (C1); unknown
       *     names return 404. Re-attaching an already-attached skill
       *     returns 409.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  project_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      skill_name: string;
                  };
              };
          };
          responses: {
              /** @description Attached */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Project or skill not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Skill already attached */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/projects/{project_id}/skills/{skill_name}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              project_id: string;
              skill_name: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /**
       * Detach a skill from the project
       * @description Removes the project↔skill join row. The skill itself is
       *     registry-canonical and untouched. Detaching a skill that is
       *     not attached returns 404 (idempotency-violating; clients
       *     should treat 204 and 404 as terminal success states).
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  project_id: string;
                  skill_name: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Detached */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Project or attachment not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/projects/{project_id}/files": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              project_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Attach an uploaded file to the project
       * @description Attaches an uploaded file to the project. The caller must own
       *     both the project and the file (cross-user → 404 on either).
       *     Re-attaching an already-attached file returns 409.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  project_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      /** Format: uuid */
                      file_id: string;
                  };
              };
          };
          responses: {
              /** @description Attached */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Project or file not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description File already attached */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/projects/{project_id}/files/{file_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              project_id: string;
              file_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /**
       * Detach a file from the project
       * @description Removes the project↔file join row. The file row itself is
       *     untouched (use ``DELETE /api/v1/files/{file_id}`` to soft-
       *     delete the file). Detaching a file that is not attached
       *     returns 404.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  project_id: string;
                  file_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Detached */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Project or attachment not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/projects/sandbox/ensure": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Find or create the caller's try-it sandbox matter (Wave D.2)
       * @description Idempotent find-or-create for the per-user *try-it sandbox*
       *     project. The sandbox is a system-managed matter (slug
       *     ``__sandbox__``, ``is_sandbox=true``) used to scope skill try-it
       *     conversations that should not count toward billable matter
       *     activity.
       *
       *     * First call returns 201 with a fresh row.
       *     * Subsequent calls return 200 with the same row.
       *     * If the sandbox was previously soft-deleted, the next ensure
       *       call recreates it (returns 201).
       *
       *     Concurrent callers are safe: the ``ON CONFLICT DO NOTHING`` path
       *     ensures only one row is ever created per owner.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Existing sandbox (already existed) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Project"];
                  };
              };
              /** @description Sandbox created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Project"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/chats/search": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Full-text search across chats + messages (PRD §1.7)
       * @description Wave B. Postgres ``websearch_to_tsquery`` against the
       *     ``chats.title_tsv`` + ``messages.content_tsv`` generated
       *     columns (migration 0016). Owner-scoped; archived chats are
       *     excluded. Returns ranked hits with a ``ts_headline`` snippet
       *     of the matching message (or the title itself for title hits).
       */
      get: {
          parameters: {
              query: {
                  q: string;
                  limit?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Ranked search hits */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["ChatSearchResponse"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/chats": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /** List the caller's chats (cursor-paginated) */
      get: {
          parameters: {
              query?: {
                  /** @description Filter to chats inside a specific project. */
                  project_id?: string;
                  /** @description When true, return archived chats only. Default excludes archived. */
                  archived?: boolean;
                  /** @description Opaque cursor from a previous page's `next_cursor`. */
                  cursor?: string;
                  limit?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated chats */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          items: components["schemas"]["Chat"][];
                          next_cursor: string | null;
                      };
                  };
              };
          };
      };
      put?: never;
      /** Create a new chat */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["ChatCreate"];
              };
          };
          responses: {
              /** @description Chat created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Chat"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/chats/{chat_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              chat_id: string;
          };
          cookie?: never;
      };
      /** Fetch a single chat (archived rows are visible) */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  chat_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Chat */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Chat"];
                  };
              };
              /** @description Chat does not exist or is owned by a different user */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      /** Soft-delete the chat (sets `archived_at`) */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  chat_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Chat archived */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Chat already archived or does not exist */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      /** Partial update of a chat (title or archived flag) */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  chat_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["ChatUpdate"];
              };
          };
          responses: {
              /** @description Chat updated */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Chat"];
                  };
              };
              /** @description Chat does not exist or is owned by a different user */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/chats/{chat_id}/messages": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              chat_id: string;
          };
          cookie?: never;
      };
      /** List messages in chat (cursor-paginated, oldest-first) */
      get: {
          parameters: {
              query?: {
                  /** @description Opaque cursor from a previous page's `next_cursor`. */
                  cursor?: string;
                  limit?: number;
              };
              header?: never;
              path: {
                  chat_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated messages */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          items: components["schemas"]["Message"][];
                          next_cursor: string | null;
                      };
                  };
              };
          };
      };
      put?: never;
      /**
       * Post a user message and get the model response
       * @description Posts a user message and returns the assistant response. The
       *     request's `stream` field selects between two response shapes:
       *
       *     * `stream: false` (default) → JSON response with the persisted
       *       assistant message, the routed Inference Tier, and routing
       *       metadata.
       *     * `stream: true` → Server-Sent Events stream:
       *         1. The opening `start` frame carries `lq_ai_message_id`
       *            (the persisted assistant message id) so clients can
       *            poll the row later.
       *         2. Each `delta` frame carries `lq_ai_message_id`,
       *            `routed_inference_tier`, and `applied_skills` per
       *            ADR 0007.
       *         3. The terminal `complete` frame (success) or `Error`
       *            envelope (mid-stream failure) precedes the OpenAI-style
       *            `data: [DONE]` line.
       *
       *     **C3 persistence.** The backend writes the user message row
       *     first (unconditionally), generates the assistant message UUID,
       *     forwards it to the gateway as `lq_ai_message_id` so the
       *     gateway's `inference_routing_log` row carries the same id, and
       *     persists the assistant row at end-of-stream (or end of the
       *     non-streaming response). On streaming failure the assistant
       *     row is persisted with whatever content was received and
       *     `error_code` populated for audit.
       *
       *     Citations are an empty array until M2's citation engine ships.
       *
       *     The response also surfaces the routed Inference Tier in the
       *     `X-LQ-AI-Routed-Inference-Tier` HTTP header (header-only
       *     consumers don't need to parse the body).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  chat_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["MessageCreate"];
              };
          };
          responses: {
              /** @description Either a JSON response or an SSE stream depending on `stream` */
              200: {
                  headers: {
                      /** @description Routed Inference Tier — duplicates the body field for header-only consumers */
                      "X-LQ-AI-Routed-Inference-Tier"?: 1 | 2 | 3 | 4 | 5;
                      /** @description Provider that handled the request (set by gateway) */
                      "X-LQ-AI-Routed-Provider"?: string;
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["MessagePostResponse"];
                      "text/event-stream": components["schemas"]["MessageStreamEvent"];
                  };
              };
              /** @description Invalid request (bad chat_id, empty content, malformed body) */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Missing or invalid bearer token */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Forced password change required (B2 gate) or tier-floor refusal (D1) */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Gateway returned an upstream error (provider_unavailable, etc.) */
              502: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Gateway unreachable (network failure or 5xx) */
              503: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Gateway request timed out */
              504: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/chats/{chat_id}/messages/{message_id}/citations": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              chat_id: string;
              message_id: string;
          };
          cookie?: never;
      };
      /** Get citations for a message (resolves to source documents) */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  chat_id: string;
                  message_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Citations */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Citation"][];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/chats/{chat_id}/messages/{message_id}/sources": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              chat_id: string;
              message_id: string;
          };
          cookie?: never;
      };
      /** Get external-source provenance (case law consulted) for a message (PR6c) */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  chat_id: string;
                  message_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description External sources consulted during the message turn */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /** Format: uuid */
                          id?: string;
                          /** Format: uuid */
                          message_id?: string;
                          source_kind?: string;
                          label?: string;
                          subtitle?: string | null;
                          url?: string | null;
                          external_ref?: string | null;
                          provider?: string;
                          tool?: string;
                          /** Format: date-time */
                          created_at?: string;
                      }[];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/skills": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /** List available skills */
      get: {
          parameters: {
              query?: {
                  scope?: "builtin" | "user" | "team" | "all";
                  tag?: string;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Skills */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["SkillSummary"][];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/skills/{skill_name}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              skill_name: string;
          };
          cookie?: never;
      };
      /** Get skill details (frontmatter + body + reference files) */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  skill_name: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Skill */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Skill"];
                  };
              };
              /** @description No skill with that name is in the registry. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/skills/{skill_name}/contents": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              skill_name: string;
          };
          cookie?: never;
      };
      /**
       * Full skill contents for the skill inspector (PRD §3.4 — Wave A)
       * @description Returns the same payload shape as ``GET /skills/{skill_name}``
       *     (SKILL.md frontmatter + body + reference + example files). The
       *     dedicated URL exists because PRD §3.4 names it explicitly as
       *     the contract behind the "view this skill" affordance + the
       *     skill inspector side panel. Applies the D8.1b resolution stack
       *     (user > team > built-in).
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  skill_name: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Skill (same shape as the base GET) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Skill"];
                  };
              };
              /** @description No skill with that name resolves for the caller. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/skills/{skill_name}/inputs": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              skill_name: string;
          };
          cookie?: never;
      };
      /**
       * Declared inputs (form schema) for the skill (PRD §3.4 — Wave A)
       * @description The PRD §3.4 skill-input-form pattern: skills declare inputs
       *     in their frontmatter so the UI can render a structured form
       *     rather than letting the model ask for missing context
       *     conversationally. The endpoint resolves user > team > built-in
       *     and looks for the inputs block at either the top of the
       *     frontmatter (formal-guide shape) or under ``lq_ai.inputs``
       *     (corpus reality for skills like enhance-prompt). Returns a
       *     name-only stub when the skill declares no inputs.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  skill_name: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Inputs (required + optional) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["SkillInputs"];
                  };
              };
              /** @description No skill with that name resolves for the caller. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/skills/{skill_name}/fork": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              skill_name: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Fork a built-in skill into the caller's user scope (D8)
       * @description Copies the built-in's resolved frontmatter and body into a new
       *     ``user_skills`` row owned by the caller (ADR 0012). The request
       *     body's ``new_name`` becomes the new row's slug (omitted →
       *     defaults to the source slug, which produces a same-slug shadow);
       *     ``scope`` MUST be ``user`` in D8 — ``team`` is reserved for
       *     D8.1 and returns 400.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  skill_name: string;
              };
              cookie?: never;
          };
          requestBody?: {
              content: {
                  "application/json": {
                      /** @description New slug for the user-scope row */
                      new_name?: string;
                      /**
                       * @default user
                       * @enum {string}
                       */
                      scope?: "user" | "team";
                  };
              };
          };
          responses: {
              /** @description Fork created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Skill"];
                  };
              };
              /** @description ``scope=team`` requested (deferred to D8.1). */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description A user-scope skill with that slug already exists for this user. */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/skills/autocomplete": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Typeahead for the chat composer's skill picker (Wave D.2)
       * @description Two modes based on the ``q`` query parameter:
       *
       *     * **Empty ``q``** — returns the caller's most-recently-used skills
       *       (by ``messages.applied_skills``), filled out alphabetically to
       *       ``limit`` when recents are fewer than ``limit``.
       *     * **Non-empty ``q``** — ranks the merged catalog by three signals
       *       (slash-alias prefix > slug prefix > title substring) and returns
       *       up to ``limit`` non-zero matches.
       *
       *     Shadowing: a user-scope row at the same slug as a built-in hides
       *     the built-in (ADR 0012). ``scope`` on each result distinguishes
       *     user shadows from built-ins.
       *
       *     ``limit`` is hard-clamped at 25 — a request for ``limit=50``
       *     returns 422 rather than silently truncating.
       */
      get: {
          parameters: {
              query?: {
                  /** @description Substring to match. Empty returns recents. */
                  q?: string;
                  limit?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Autocomplete results (may be empty) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          results: {
                              slug: string;
                              slash_alias?: string | null;
                              title: string;
                              description?: string | null;
                              /** @enum {string} */
                              scope: "builtin" | "user" | "team";
                              icon?: string | null;
                          }[];
                      };
                  };
              };
              /** @description limit out of range (must be 1–25). */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/user-skills": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the caller's editable skills (user-scope by default; ?scope=team|all)
       * @description Returns the rich ``UserSkill`` view (body + frontmatter_extra
       *     included) for the management UI. The picker-side merge view
       *     lives at ``GET /api/v1/skills?scope=all`` (summary shape).
       *
       *     Scope filter (D8.1c — default ``user`` for back-compat):
       *
       *     * ``user`` — caller's user-scope rows only.
       *     * ``team`` — team-scope rows from teams where the caller is a
       *       team-admin. (Non-admin members read team skills in the picker,
       *       not here, since they can't mutate.)
       *     * ``all`` — both layers merged + sorted by ``updated_at DESC``.
       */
      get: {
          parameters: {
              query?: {
                  scope?: "user" | "team" | "all";
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description List of editable skill rows for the caller */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["UserSkill"][];
                  };
              };
          };
      };
      put?: never;
      /**
       * Create a user- or team-scope skill (D8 + D8.1b)
       * @description Creates a new skill row. Scope branches (per ADR 0012 + D8.1b):
       *
       *     * ``scope='user'`` (default) — owned by the caller. Slug
       *       collision with the caller's existing non-archived rows
       *       returns 409. Collision with a filesystem built-in is
       *       **allowed** — the deliberate shadow case; the user's row
       *       wins for their chats.
       *     * ``scope='team'`` — owned by ``owner_team_id``. Caller must
       *       be a team-admin of that team or 404 (id-probing-safe).
       *       Slug collision within the team's non-archived rows returns
       *       409. The D8.1b resolver picks user > team > built-in.
       *
       *     422 fires when ``scope`` and ``owner_team_id`` are inconsistent.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["UserSkillCreate"];
              };
          };
          responses: {
              /** @description Created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["UserSkill"];
                  };
              };
              /** @description Team referenced by owner_team_id does not exist OR caller is not a team-admin (id-probing-safe). */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Slug collides with the caller's user-scope rows OR the named team's team-scope rows. */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description scope/owner_team_id combination is invalid (team missing team id, or user carrying team id). */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/teams": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List teams the caller belongs to (newest first)
       * @description Each row carries ``caller_role`` (admin | member) so the UI can
       *     render mutate affordances without a second round-trip. The
       *     optional ``?role=`` filter (D8.1c) restricts to a specific
       *     role — the team-scope skill creation picker uses
       *     ``?role=admin``.
       */
      get: {
          parameters: {
              query?: {
                  role?: "admin" | "member";
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Caller's teams (with caller_role populated) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TeamSummary"][];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/teams/{team_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              team_id: string;
          };
          cookie?: never;
      };
      /** Fetch a team (member-only; 404 conflates "no such team" and "not a member") */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  team_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Team payload with member roster */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Team"];
                  };
              };
              /** @description Team does not exist OR caller is not a member. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/teams": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /** List every team in the deployment (admin) */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description All teams */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TeamSummary"][];
                  };
              };
          };
      };
      put?: never;
      /** Create a new team; admin is auto-added as the first admin member */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["TeamCreate"];
              };
          };
          responses: {
              /** @description Created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Team"];
                  };
              };
              /** @description A team with that slug already exists. */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/teams/{team_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              team_id: string;
          };
          cookie?: never;
      };
      /** Fetch a team with its member roster (admin) */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  team_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Team payload */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Team"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      /** Delete a team; CASCADES to team_members and team-scope user_skills */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  team_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Deleted */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      /** Update name / description (admin) */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  team_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["TeamUpdate"];
              };
          };
          responses: {
              /** @description Updated team */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Team"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/admin/teams/{team_id}/members": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              team_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      /** Add a user to a team (admin) */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  team_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      /** Format: uuid */
                      user_id: string;
                      /**
                       * @default member
                       * @enum {string}
                       */
                      role?: "admin" | "member";
                  };
              };
          };
          responses: {
              /** @description Member added */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TeamMember"];
                  };
              };
              /** @description User is already a member of this team. */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/teams/{team_id}/members/{user_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              team_id: string;
              user_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /** Remove a user from a team (admin) */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  team_id: string;
                  user_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Member removed */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      /** Change a member's role (admin) */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  team_id: string;
                  user_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      /** @enum {string} */
                      role: "admin" | "member";
                  };
              };
          };
          responses: {
              /** @description Updated membership */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TeamMember"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/user-skills/{skill_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              skill_id: string;
          };
          cookie?: never;
      };
      /**
       * Fetch a single user- or team-scope skill (owner or team-admin)
       * @description Owner-only for ``scope='user'`` rows; team-admin-only for
       *     ``scope='team'`` rows (D8.1b). Non-admin team members read team
       *     skills through the merged picker at ``GET /api/v1/skills/{slug}``,
       *     not through this management endpoint.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  skill_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Skill row */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["UserSkill"];
                  };
              };
              /** @description Skill not found OR caller is not the owner / not a team-admin (id-probing-safe). */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      /**
       * Soft-delete (owner or team-admin)
       * @description Owner-only for ``scope='user'`` rows; team-admin-only for
       *     ``scope='team'`` rows (D8.1b). Sets ``archived_at = now()``.
       *     The slug is freed for a new skill at the same slug after
       *     archive. Audit log records the deletion with the row's
       *     identity; team-scope rows carry ``team_id`` in the details bag.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  skill_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Deleted */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Skill not found OR caller is not the owner / not a team-admin. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Skill is already archived. */
              410: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      /**
       * Partial update (owner or team-admin)
       * @description Owner-only for ``scope='user'`` rows; team-admin-only for
       *     ``scope='team'`` rows (D8.1b). Audit details on team-scope
       *     rows carry ``team_id`` alongside slug + changed fields.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  skill_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["UserSkillUpdate"];
              };
          };
          responses: {
              /** @description Updated row */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["UserSkill"];
                  };
              };
              /** @description Skill not found OR caller is not the owner / not a team-admin. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/user-skills/{skill_id}/versions": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              skill_id: string;
          };
          cookie?: never;
      };
      /**
       * Audit-log view of edits for this user-skill (Wave D.2)
       * @description Returns ``audit_log`` rows for ``resource_type='user_skill'``
       *     keyed by this skill id, ordered ``timestamp DESC`` (newest first).
       *     The timeline UI renders top-down so the most recent edit appears
       *     at the top; ``user_skill.created`` lands last.
       *
       *     Access gate mirrors the mutable surface: owner-only for
       *     ``scope='user'`` rows; team-admin-only for ``scope='team'`` rows.
       *     404 conflates "no such id" and "not your skill" (id-probing-safe).
       *     Active AND archived rows are accessible so a freshly-archived
       *     skill's timeline can still be rendered.
       */
      get: {
          parameters: {
              query?: {
                  limit?: number;
              };
              header?: never;
              path: {
                  skill_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Version history items, newest first */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          items: {
                              /** Format: date-time */
                              timestamp: string;
                              /** Format: uuid */
                              actor_user_id?: string | null;
                              actor_email?: string | null;
                              /** @description e.g. 'user_skill.created' or 'user_skill.updated' */
                              action: string;
                              version?: string | null;
                              details?: {
                                  [key: string]: unknown;
                              } | null;
                          }[];
                      };
                  };
              };
              /** @description Skill not found OR caller is not the owner / not a team-admin. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/models": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List available models — proxy to gateway /v1/models (D0)
       * @description Authenticated proxy that forwards the gateway's merged
       *     ``GET /v1/models`` payload (aliases + live-discovered Ollama
       *     tags + live-discovered Anthropic catalog rows). The LQ.AI shell's
       *     model picker consumes this endpoint; the response shape is
       *     identical to the gateway's per
       *     ``docs/api/gateway-openapi.yaml`` so the contract stays single-
       *     sourced.
       *
       *     Auth: bearer token + cleared ``must_change_password``. The
       *     picker contents reveal which providers the operator has
       *     configured, so anonymous reads are intentionally not allowed.
       *
       *     Errors:
       *     - Gateway timeout → 504 ``gateway_timeout``.
       *     - Gateway unreachable / 5xx / 401 → 503 ``gateway_unreachable``.
       *       A 401 from the gateway is operator-side misconfiguration; the
       *       user must not see the underlying detail.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Model list */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /** @enum {string} */
                          object: "list";
                          data: {
                              id: string;
                              /** @enum {string} */
                              object: "model";
                              created: number;
                              owned_by: string;
                              /** @enum {string} */
                              lq_ai_kind: "alias" | "provider_native";
                              /** @enum {integer} */
                              routed_inference_tier?: 1 | 2 | 3 | 4 | 5;
                              /** @enum {string} */
                              provider_type?: "anthropic" | "openai" | "vertex" | "cohere" | "azure_openai" | "bedrock" | "ollama" | "vllm" | "openai_compatible";
                              lq_ai_resolves_to?: string;
                              lq_ai_fallback_count?: number;
                          }[];
                      };
                  };
              };
              /** @description Missing or invalid bearer token */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Gateway unreachable */
              503: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Gateway timed out */
              504: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/internal/skills/{skill_name}": {
      parameters: {
          query?: {
              /**
               * @description When supplied, the resolver applies the D8.1b stack (per
               *     ADR 0012): user shadow → team shadow → filesystem built-in.
               *     A non-archived ``user_skills`` row for that user at this slug
               *     wins outright; otherwise the newest non-archived team-scope
               *     row owned by any team the user is a member of wins;
               *     otherwise the filesystem-canonical built-in is returned.
               *     When omitted, the registry view (built-in only) is returned.
               */
              user_id?: string;
          };
          header?: never;
          path: {
              skill_name: string;
          };
          cookie?: never;
      };
      /**
       * Internal — fetch a skill (gateway → backend; user > team > built-in)
       * @description Service-to-service endpoint used by the Inference Gateway during
       *     prompt assembly (Task C2 / ADR 0007). The user-facing
       *     `GET /api/v1/skills/{name}` endpoint is gated by user-token auth
       *     (`get_active_user`) and is inappropriate for the gateway's calls
       *     — the gateway has no user. This route is gated by the shared
       *     `X-LQ-AI-Gateway-Key` secret instead.
       *
       *     Trust-domain separation: user-facing routes stay under user-token
       *     auth; internal routes stay under shared-secret auth. The two
       *     never mix on a single route.
       *
       *     The optional ``user_id`` query param activates the D8.1b
       *     resolution stack (user > team > built-in). Multi-team conflicts
       *     resolve to the row with the most recent ``updated_at``. The
       *     gateway's skill cache stays keyed on ``(name, user_id)``;
       *     team-membership changes propagate via the existing TTL.
       *
       *     The response shape matches `GET /api/v1/skills/{name}` (the
       *     `Skill` schema) so the gateway-side client reuses the same
       *     response model.
       */
      get: {
          parameters: {
              query?: {
                  /**
                   * @description When supplied, the resolver applies the D8.1b stack (per
                   *     ADR 0012): user shadow → team shadow → filesystem built-in.
                   *     A non-archived ``user_skills`` row for that user at this slug
                   *     wins outright; otherwise the newest non-archived team-scope
                   *     row owned by any team the user is a member of wins;
                   *     otherwise the filesystem-canonical built-in is returned.
                   *     When omitted, the registry view (built-in only) is returned.
                   */
                  user_id?: string;
              };
              header?: never;
              path: {
                  skill_name: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Skill detail */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Skill"];
                  };
              };
              /** @description Missing or invalid `X-LQ-AI-Gateway-Key`. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description No skill with that name is in the registry. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /**
               * @description Operator has not configured `LQ_AI_GATEWAY_KEY` on the
               *     backend; service-to-service traffic is refused rather than
               *     silently accepted.
               */
              500: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/internal/organization-profile": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Internal — fetch the deployment's Organization Profile (gateway → backend)
       * @description Service-to-service endpoint used by the Inference Gateway during
       *     prompt assembly (Task D4-coverage). Returns the Organization
       *     Profile (PRD §3.12) as a `Skill`-shaped JSON body so the
       *     gateway can plug it into the same prompt-assembler that
       *     consumes user-attached skills. The synthesized frontmatter
       *     carries `is_organization_profile: true` and
       *     `use_organization_profile: false` so consumers identify the
       *     Profile by metadata and the assembler never recursively
       *     re-prepends the Profile to itself.
       *
       *     Same trust posture as `/internal/skills/{name}`:
       *     `X-LQ-AI-Gateway-Key` shared-secret auth (constant-time
       *     compare); user-facing reads of the Profile use the bearer-
       *     authed `/api/v1/organization-profile` route instead.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Profile present; body is the `Skill`-shaped synthesized payload. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Skill"];
                  };
              };
              /** @description Missing or invalid `X-LQ-AI-Gateway-Key`. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /**
               * @description No Profile is set on this deployment, or the Profile's body
               *     is empty. The gateway treats this as "no Profile to
               *     prepend" and proceeds with skill-only prompt assembly.
               */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /**
               * @description Operator has not configured `LQ_AI_GATEWAY_KEY` on the
               *     backend; service-to-service traffic is refused rather than
               *     silently accepted.
               */
              500: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/files": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Upload a file
       * @description Streaming multipart upload. The body is streamed to MinIO without
       *     loading the whole file into memory; a SHA-256 is computed as bytes
       *     flow past, and metadata is persisted with `ingestion_status='pending'`.
       *     The document pipeline (Task C5) picks the row up asynchronously
       *     and flips status through `processing` → `ready` (or `failed`).
       *
       *     Per-request size limit: `LQ_AI_MAX_UPLOAD_SIZE_MB` (default 100 MB
       *     per Task C4). Exceeding it returns 413 with `code=payload_too_large`.
       *
       *     `project_id` is accepted for forward compatibility (it appears in
       *     the multipart body) but is currently ignored; project attachment
       *     lands in C7. Files always start unattached and are linked to a
       *     project via `POST /api/v1/projects/{project_id}/files` (C7).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "multipart/form-data": {
                      /** Format: binary */
                      file: string;
                      /** Format: uuid */
                      project_id?: string | null;
                  };
              };
          };
          responses: {
              /** @description File uploaded; ingestion may be async. */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["File"];
                  };
              };
              /** @description Validation error (e.g., missing filename on multipart part). */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Missing or invalid bearer token. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description User must change their password before uploading (B2 gate). */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /**
               * @description Uploaded body exceeds the per-request size cap
               *     (`LQ_AI_MAX_UPLOAD_SIZE_MB`, default 100 MB). The response
               *     body's `details` carries `limit_bytes` and `received_bytes`.
               */
              413: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/files/{file_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              file_id: string;
          };
          cookie?: never;
      };
      /** Get file metadata */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  file_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description File metadata. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["File"];
                  };
              };
              /** @description `file_id` is not a valid UUID. */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Missing or invalid bearer token. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /**
               * @description File does not exist, has been soft-deleted, or is owned by a
               *     different user. The cross-user case returns 404 (not 403) to
               *     avoid leaking existence information.
               */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      /**
       * Soft-delete a file
       * @description Sets `deleted_at` on the row; the MinIO object is left in place
       *     and reaped later by D6 (per-user export+delete) or a future GC
       *     sweep, per `docs/adr/0005-file-storage-soft-delete-and-key-scheme.md`.
       *     Idempotent: deleting an already-soft-deleted or missing file
       *     returns 404.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  file_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description File soft-deleted (no body). */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description `file_id` is not a valid UUID. */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Missing or invalid bearer token. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description File missing, soft-deleted, or owned by a different user. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/files/{file_id}/content": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              file_id: string;
          };
          cookie?: never;
      };
      /**
       * Download original file content
       * @description Streams the original bytes back as the upload arrived. The
       *     `Content-Type` is the stored MIME type, `Content-Length` is the
       *     stored size in bytes, and `Content-Disposition` is
       *     `attachment; filename="..."` with an RFC 5987 `filename*=UTF-8''...`
       *     for non-ASCII filenames.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  file_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description File bytes (streaming). */
              200: {
                  headers: {
                      /**
                       * @description `attachment; filename="..."` (RFC 6266); for non-ASCII
                       *     filenames an additional RFC 5987 `filename*=UTF-8''...`
                       *     parameter is included.
                       */
                      "Content-Disposition"?: string;
                      /** @description Always `nosniff`. */
                      "X-Content-Type-Options"?: string;
                      [name: string]: unknown;
                  };
                  content: {
                      "application/octet-stream": unknown;
                  };
              };
              /** @description `file_id` is not a valid UUID. */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Missing or invalid bearer token. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description File missing, soft-deleted, or owned by a different user. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/knowledge-bases": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /** List the caller's knowledge bases */
      get: {
          parameters: {
              query?: {
                  /** @description When true, list archived KBs. Default (omit) lists active only. */
                  archived?: boolean;
                  /** @description Filter to KBs associated with this project. */
                  project_id?: string;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description KBs accessible to the user */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["KnowledgeBase"][];
                  };
              };
          };
      };
      put?: never;
      /** Create a knowledge base */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["KnowledgeBaseCreate"];
              };
          };
          responses: {
              /** @description KB created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["KnowledgeBase"];
                  };
              };
              /** @description Project (if `project_id` was provided) not found. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/knowledge-bases/{kb_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              kb_id: string;
          };
          cookie?: never;
      };
      /** Fetch a single knowledge base with metadata + file count */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  kb_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Knowledge base */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["KnowledgeBase"];
                  };
              };
              /** @description Not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      /** Soft-delete a knowledge base */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  kb_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Soft-deleted */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      /** Partial update — name, description, project association, alpha, or archived */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  kb_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["KnowledgeBaseUpdate"];
              };
          };
          responses: {
              /** @description Updated */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["KnowledgeBase"];
                  };
              };
              /** @description Not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/knowledge-bases/{kb_id}/files": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              kb_id: string;
          };
          cookie?: never;
      };
      /**
       * List the files attached to a knowledge base
       * @description Returns the files currently attached to the KB (the `File`
       *     shape from `GET /files/{id}` plus the `attached_at` timestamp
       *     from the join). Owner-scoped — cross-user / unknown KB id
       *     returns 404. Soft-deleted files are excluded. Sorted by
       *     `attached_at DESC` so the most recent uploads surface first.
       *
       *     Drives the Knowledge surface's detail-page document list per
       *     the M1 frontend design spec (Wave C).
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  kb_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description List of attached files */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["KBFile"][];
                  };
              };
              /** @description KB not found / cross-user */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      /**
       * Attach a file to a knowledge base
       * @description The file must be owned by the caller and have completed the C5
       *     ingest pipeline (`ingestion_status='ready'`). After successful
       *     attach the backend enqueues an embed job; the query path also
       *     covers any unembedded chunks lazily (embed-on-read).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  kb_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      /** Format: uuid */
                      file_id: string;
                  };
              };
          };
          responses: {
              /** @description Attached */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description file_id is malformed */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description KB or file not found / cross-user */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description File already attached to this KB (idempotency-violating POST) */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description File is not in `ingestion_status='ready'` */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/knowledge-bases/{kb_id}/files/{file_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              kb_id: string;
              file_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /** Detach a file from a knowledge base */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  kb_id: string;
                  file_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Detached */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description KB not found, or the file is not attached */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/knowledge-bases/{kb_id}/query": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              kb_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Hybrid (vector + FTS) search over the knowledge base
       * @description Per ADR 0008 the score is `(1 - alpha) * vector + alpha * fts`,
       *     where each side is min-max normalized across the union of the
       *     per-side candidate sets (each side returns up to `top_k * 4`
       *     candidates). `hybrid_alpha` defaults to the KB's stored value
       *     (which itself defaults to 0.5).
       *
       *     Embed-on-read: if the gateway's `/v1/embeddings` is unavailable
       *     the query degrades gracefully to FTS-only ranking; the response
       *     carries `score_components.vector = 0` for every result in that
       *     case so the client can detect the degraded mode.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  kb_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["KBQueryRequest"];
              };
          };
          responses: {
              /** @description Search results */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["KBQueryResponse"];
                  };
              };
              /** @description KB not found / cross-user */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/organization-profile": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Get the deployment's Organization Profile (singleton)
       * @description Bearer-authenticated. Readable by every authenticated user
       *     (PRD §1.3 transparency: users are entitled to see what's
       *     shaping their output). Returns `content_md=""` plus null
       *     timestamps when no admin has set a Profile yet — the read
       *     path never 404s.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Organization Profile (or empty placeholder) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          content_md: string;
                          /** Format: date-time */
                          updated_at?: string | null;
                          /** Format: uuid */
                          updated_by?: string | null;
                      };
                  };
              };
          };
      };
      /**
       * Update the Organization Profile (admin only)
       * @description Admin-only upsert: idempotent against the singleton row. Empty
       *     `content_md` is allowed (operators may want to clear without
       *     deleting). Audit-logged as `organization_profile.updated`.
       */
      put: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      content_md: string;
                  };
              };
          };
          responses: {
              /** @description Updated */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          content_md: string;
                          /** Format: date-time */
                          updated_at?: string | null;
                          /** Format: uuid */
                          updated_by?: string | null;
                      };
                  };
              };
              /** @description Bearer token missing or invalid */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/organization-profile/raw": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Get the Profile body as raw Markdown
       * @description Bearer-authenticated. Convenience endpoint for the Skill
       *     Inspector (§3.4) and any UI surface that wants to render the
       *     Profile as Markdown without JSON-decoding the body. Returns
       *     an empty 200 when no Profile is set.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Profile body */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "text/markdown": unknown;
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/saved-prompts": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description User's saved prompts */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["SavedPrompt"][];
                  };
              };
          };
      };
      put?: never;
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      name: string;
                      prompt_text: string;
                      tags?: string[];
                  };
              };
          };
          responses: {
              /** @description Created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["SavedPrompt"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/saved-prompts/{prompt_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              prompt_id: string;
          };
          cookie?: never;
      };
      /** Fetch a single saved prompt */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  prompt_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Saved prompt */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["SavedPrompt"];
                  };
              };
              /** @description Not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  prompt_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Deleted */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  prompt_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      name?: string;
                      prompt_text?: string;
                      tags?: string[];
                  };
              };
          };
          responses: {
              /** @description Updated */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["SavedPrompt"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/admin/audit-log": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /** Query audit log (admin only) */
      get: {
          parameters: {
              query?: {
                  user_id?: string;
                  action?: string;
                  resource_type?: string;
                  privilege_marked?: boolean;
                  routed_inference_tier?: 1 | 2 | 3 | 4 | 5;
                  from?: string;
                  to?: string;
                  cursor?: string;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Audit log entries */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          items: components["schemas"]["AuditLogEntry"][];
                          next_cursor: string | null;
                      };
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/playbooks": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List playbooks visible to the caller (M3-A4)
       * @description Returns playbooks the caller can see: admins see all;
       *     non-admins see playbooks they authored or built-in playbooks
       *     (``created_by IS NULL``). Soft-deleted rows (``deleted_at IS NOT
       *     NULL``) are excluded for everyone, including admins. Positions
       *     are NOT inlined; clients call ``GET /api/v1/playbooks/{id}`` to
       *     fetch them.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description List of playbooks (positions empty). */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Playbook"][];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      /**
       * Create a new playbook (M3-A6)
       * @description Creates a playbook owned by the caller (``created_by =
       *     caller.id``). Admins do not get to mint built-ins through this
       *     endpoint — built-ins (``created_by IS NULL``) ship via seed
       *     migration only. The Inference-Tier and audit posture matches
       *     other write endpoints on the API.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["PlaybookCreate"];
              };
          };
          responses: {
              /** @description Playbook created. Body includes the assembled positions. */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Playbook"];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Validation error (e.g., unknown field, invalid severity enum). */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/playbooks/{playbook_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              playbook_id: string;
          };
          cookie?: never;
      };
      /**
       * Get a playbook with its full position list (M3-A4)
       * @description Returns the playbook header + positions + fallback tiers.
       *     Visibility matches ``GET /api/v1/playbooks``. 404 (not 403)
       *     on unauthorized access, including for soft-deleted rows.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  playbook_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Full playbook with positions. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Playbook"];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Playbook not found, or caller is not authorized to see it. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      /**
       * Soft-delete a playbook (M3-A6)
       * @description Sets ``deleted_at`` on the row. The ``playbook_positions`` rows
       *     remain so historical executions still resolve their position
       *     references. Authorization mirrors PATCH: built-ins are 403;
       *     non-built-ins require admin OR ownership; cross-user / already-
       *     deleted is 404. Subsequent reads (GET, list) treat the row as
       *     absent.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  playbook_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Playbook soft-deleted. */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Built-in playbooks cannot be deleted through this endpoint. */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Playbook not found, already soft-deleted, or not authorized. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      /**
       * Update a playbook header; optionally replace positions (M3-A6)
       * @description Patches the playbook. Authorization:
       *
       *     * Built-in playbooks (``created_by IS NULL``) are 403 to
       *       everyone, including admins — operators fork-then-edit. This
       *       keeps shared deployment-level content immutable to a single
       *       operator's mistake.
       *     * Non-built-in playbooks can be patched by the playbook's author
       *       OR by an admin. Cross-user / soft-deleted cases return 404.
       *
       *     Position replacement is atomic: when ``positions`` is supplied,
       *     every existing position row for this playbook is deleted and
       *     the new list is inserted in a single transaction.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  playbook_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["PlaybookUpdate"];
              };
          };
          responses: {
              /** @description Playbook updated; response is the fresh full shape. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Playbook"];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Built-in playbooks cannot be edited through this endpoint. */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Playbook not found, soft-deleted, or not authorized. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Validation error. */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      trace?: never;
  };
  "/api/v1/playbooks/easy": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Start an Easy Playbook generation run (M3-A6)
       * @description Kicks off the Easy Playbook auto-generation pipeline against
       *     the supplied document corpus. Creates an
       *     ``EasyPlaybookGeneration`` row at ``status='pending'`` and
       *     enqueues the ARQ worker job on the ``arq:m3a6`` queue (the
       *     dedicated M3-A6 worker — see ``app/workers/arq_setup.py``).
       *     Returns 202 immediately; the wizard's Step 2 polls
       *     ``GET /api/v1/playbooks/easy/{generation_id}`` until status
       *     reaches a terminal value.
       *
       *     Authorization: caller must own every document in
       *     ``document_ids`` (admins bypass). Cross-user / missing /
       *     soft-deleted documents collapse into 404.
       *
       *     Generation completion does NOT mean the playbook is fit for
       *     use; the wizard's Step 3 inline editor is where the user-
       *     attorney validates and edits before the final save (which
       *     POSTs to ``/api/v1/playbooks`` like any other playbook).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["EasyPlaybookGenerationCreate"];
              };
          };
          responses: {
              /** @description Generation scheduled; row created at status `pending`. */
              202: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["EasyPlaybookGeneration"];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description One or more documents not found / not authorized. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Validation error (empty ``document_ids``, unknown field, etc.). */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/playbooks/easy/{generation_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              generation_id: string;
          };
          cookie?: never;
      };
      /**
       * Poll an Easy Playbook generation row (M3-A6)
       * @description Returns the current state of one Easy Playbook generation.
       *     Caller must be the row's user OR an admin; cross-user / missing
       *     rows return 404.
       *
       *     When ``status='completed'``, ``draft_playbook`` carries the
       *     assembled ``PlaybookCreate`` shape — the wizard's Step 3 inline
       *     editor binds to this. When ``status='error'``, ``error_message``
       *     is populated. The wizard's Step 2 polls every few seconds until
       *     a terminal status arrives.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  generation_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Current generation row. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["EasyPlaybookGeneration"];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Generation not found or not authorized. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/tabular/preview-cost": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Preview the cost of a proposed tabular execution (M3-C2)
       * @description Synchronous cost preview — no execution row is created. The UI
       *     calls this before showing the confirmation modal so the
       *     operator sees the cell-count + estimated cost + per-tier
       *     breakdown (Phase C prep doc Decision C-5).
       *
       *     Either ``skill_name`` or ``columns`` is required (not both).
       *     The estimator uses a rolling-average over recent
       *     ``purpose='tabular_extraction'`` routing-log rows; cold-start
       *     deployments see the conservative default per-cell cost until
       *     enough calibration data accumulates.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["TabularPreviewCostRequest"];
              };
          };
          responses: {
              /** @description Cost preview. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TabularPreviewCostResponse"];
                  };
              };
              /** @description Both ``skill_name`` and ``columns`` provided, or skill has no columns. */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description ``skill_name`` not found in the live skill registry. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Validation error (empty ``document_ids``, malformed column spec, etc.). */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/tabular/execute": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Start a tabular execution (M3-C2)
       * @description Kicks off a tabular execution against the supplied document
       *     corpus. Creates a ``TabularExecution`` row at
       *     ``status='pending'`` and enqueues the ARQ worker job on the
       *     shared playbook queue (per Decision C-3 — same queue as Easy
       *     Playbook). Returns 202 immediately; the result view polls
       *     ``GET /api/v1/tabular/executions/{id}`` until status reaches
       *     a terminal value.
       *
       *     Authorization: caller must own every document in
       *     ``document_ids`` (admins bypass). Cross-user / missing /
       *     soft-deleted documents collapse into 404.
       *
       *     Execution completion does NOT mean every cell is correct —
       *     the result view's per-cell citation drawer is where the
       *     user-attorney validates extractions before relying on them.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["TabularExecutionCreate"];
              };
          };
          responses: {
              /** @description Execution scheduled; row created at status `pending`. */
              202: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TabularExecution"];
                  };
              };
              /** @description Both ``skill_name`` and ``columns`` provided, or skill has no columns. */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description One or more documents not found / not authorized, or skill not found. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Validation error. */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/tabular/executions": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the caller's tabular executions (M3-C2)
       * @description Returns the caller's tabular executions in recent-first order.
       *     Soft-deleted rows are excluded. Admins see all rows; non-admins
       *     see only their own.
       */
      get: {
          parameters: {
              query?: {
                  /** @description Maximum rows to return; default 50. */
                  limit?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description List of tabular execution summaries. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TabularExecutionSummary"][];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/tabular/executions/{execution_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              execution_id: string;
          };
          cookie?: never;
      };
      /**
       * Get a tabular execution by id (M3-C2)
       * @description Returns the full execution — status, results grid, costs,
       *     timing. Caller must be the row's user OR an admin; cross-user
       *     / missing / soft-deleted rows return 404.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  execution_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Current execution row. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TabularExecution"];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Execution not found or not authorized. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      /**
       * Soft-delete a tabular execution (M3-C2)
       * @description Sets ``deleted_at`` to now. Soft-deleted rows are invisible
       *     to list / get / cancel endpoints; subsequent operations
       *     return 404.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  execution_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Soft-deleted. */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Execution not found or already deleted. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/tabular/executions/{execution_id}/cancel": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              execution_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Cancel a pending or running tabular execution (M3-C2)
       * @description Sets status to ``cancelled`` and ``completed_at`` to now.
       *     The worker's per-cell loop checks the row status at each
       *     cell-iteration boundary; on cancellation it stops accepting
       *     new cells and the aggregate node writes whatever partial
       *     results landed. Terminal rows (``completed`` / ``failed`` /
       *     ``cancelled``) return 409 — operators wanting a clean re-run
       *     start a new execution via ``POST /tabular/execute``.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  execution_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Cancellation accepted; row updated. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TabularExecution"];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Execution not found or not authorized. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Execution already in a terminal status. */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/tabular/executions/{execution_id}/export": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              execution_id: string;
          };
          cookie?: never;
      };
      /**
       * Export a completed tabular grid as XLSX or CSV (M3-C4a)
       * @description Streams the tabular grid in the requested format. Both formats
       *     carry the document column (leftmost) plus one column per declared
       *     column spec, in spec order. Cells with ``confidence='failed'``
       *     render as ``"(failed)"`` so operators can spot gaps.
       *
       *     Citation surfacing differs by format:
       *
       *     * **XLSX** — each grid cell with at least one citation carries an
       *       openpyxl cell ``Comment`` listing the citation ids + confidences
       *       (up to 5 per comment; the cell retains the full count). Operators
       *       hover any cell in Excel / Numbers / Google Sheets to see sources.
       *     * **CSV** — a trailing ``citation_links`` column per row carries a
       *       semicolon-separated list of ``"<column_name>:<citation_id>"``
       *       pairs across the row's cells; empty when no cell had citations.
       *
       *     The execution must be in ``status='completed'`` — pending /
       *     running / cancelled / failed rows return 409 (partial grids would
       *     mislead downstream consumers).
       */
      get: {
          parameters: {
              query?: {
                  /** @description Export format. `xlsx` carries citations as cell comments; `csv` flattens them into a `citation_links` column. */
                  format?: "xlsx" | "csv";
              };
              header?: never;
              path: {
                  execution_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Streaming export; `Content-Type` matches the format. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": string;
                      "text/csv": string;
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Execution not found or not authorized. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Execution not in a terminal `completed` status — cannot export. */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/playbooks/{playbook_id}/execute": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              playbook_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Kick off a playbook execution against a target document (M3-A2)
       * @description Creates a new ``playbook_executions`` row at status ``'pending'``
       *     and schedules the four-node LangGraph workflow
       *     (retrieve → classify → redline → compile) as a FastAPI
       *     BackgroundTask. The response returns immediately (202) with the
       *     new row; clients poll
       *     ``GET /api/v1/playbook-executions/{execution_id}`` until they
       *     see a terminal status (``completed`` or ``error``).
       *
       *     Authorization: caller must be an admin or the playbook's
       *     author, and own the target document's parent file. If
       *     ``project_id`` is supplied, caller must also own the project.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  playbook_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      /** Format: uuid */
                      target_document_id: string;
                      /** Format: uuid */
                      project_id?: string | null;
                  };
              };
          };
          responses: {
              /** @description Execution scheduled; row created at status `pending`. */
              202: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["PlaybookExecution"];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Playbook, target document, or project not found / not owned. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Request body validation error (e.g., missing or malformed `target_document_id`, unknown field). */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/playbook-executions/{execution_id}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              execution_id: string;
          };
          cookie?: never;
      };
      /**
       * Poll the current state of a playbook execution (M3-A2)
       * @description Returns the row regardless of completion state. Callers poll
       *     until they see a terminal ``completed`` or ``error`` status.
       *     Authorization: caller must own the execution (``user_id``
       *     match) or be an admin.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  execution_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Current execution state. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["PlaybookExecution"];
                  };
              };
              /** @description Not authenticated. */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Execution not found or caller does not own it. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/ingest-health": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Aggregate ingest-status counts across the deployment (admin-only)
       * @description Reports document-level + file-level ingest health in a single
       *     response: ``ok`` (chunks embedded), ``embed_failed`` /
       *     ``partial`` (document-level post-parse failures introduced by
       *     M3-0.3 / DE-276), and ``parse_failed`` (file-level parse
       *     failures from the M1 pipeline). Soft-deleted rows are excluded.
       *
       *     A non-zero ``embed_failed`` or ``partial`` count is the
       *     operator's canonical signal that hybrid retrieval has silently
       *     degraded for some documents — the exact failure mode DE-276
       *     was filed to surface. A non-zero ``parse_failed`` count means
       *     operators should inspect the file-list UI for the specific
       *     failures.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Aggregate ingest-health summary */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /** @description Documents with all chunks successfully embedded. */
                          ok: number;
                          /**
                           * @description Documents whose embed worker raised before any chunk
                           *     was embedded — hybrid retrieval falls back to FTS-only.
                           */
                          embed_failed: number;
                          /**
                           * @description Documents whose embed worker raised mid-batch — some
                           *     chunks have vectors, others are NULL.
                           */
                          partial: number;
                          /**
                           * @description Files that failed at parse time and never produced a
                           *     ``documents`` row (``files.ingestion_status='failed'``).
                           */
                          parse_failed: number;
                          /** @description Sum of ok + embed_failed + partial. */
                          total_documents: number;
                      };
                  };
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/bootstrap-status": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Report whether the first-run bootstrap admin password is still active
       * @description **Unauthenticated.** Consulted by the login UI before the operator
       *     has credentials, so it can render a fresh-install hint pointing at
       *     the API container logs when the bootstrap password has not yet
       *     been rotated (M3-0.1 / DE-283).
       *
       *     ``default_password_active`` is True when at least one non-deleted
       *     admin user still has ``must_change_password=True``. The flag flips
       *     to False once the operator hits ``POST /api/v1/auth/change-password``,
       *     at which point the login UI stops surfacing the hint.
       *
       *     The signal exposed by this endpoint is low-sensitivity: the
       *     bootstrap password is 24 characters of CSPRNG output, so knowing
       *     a deployment is in fresh-install state does not measurably help
       *     an attacker who lacks the log line.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Bootstrap state */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /**
                           * @description True when at least one admin user is still in the
                           *     ``must_change_password=True`` state, indicating the
                           *     first-run bootstrap password has not been rotated.
                           */
                          default_password_active: boolean;
                          /**
                           * @description Shell command an operator can run to retrieve the
                           *     bootstrap password from the API container's logs.
                           */
                          logs_hint: string;
                      };
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/aliases": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List configured model aliases (admin only)
       * @description Proxies the gateway's ``/admin/v1/aliases`` surface. The user's
       *     bearer token must have ``is_admin = true`` or the endpoint
       *     returns 403 ``forbidden``.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Alias list */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /** @enum {string} */
                          object: "list";
                          data: components["schemas"]["AdminAliasEntry"][];
                      };
                  };
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      /** Create a new model alias (admin only) */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["AdminAliasCreate"];
              };
          };
          responses: {
              /** @description Alias created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AdminAliasEntry"];
                  };
              };
              /** @description Alias name already configured */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/aliases/{name}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              name: string;
          };
          cookie?: never;
      };
      /** Get a single alias (admin only) */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  name: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Alias detail */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AdminAliasEntry"];
                  };
              };
              /** @description Alias not configured */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      /** Remove an alias (admin only) */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  name: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Alias removed */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Alias not configured */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      /** Update an alias (admin only) */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  name: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["AdminAliasUpdate"];
              };
          };
          responses: {
              /** @description Alias updated */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AdminAliasEntry"];
                  };
              };
              /** @description Alias not configured */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/admin/provider-keys": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List provider-key status (admin only)
       * @description Donna #7 (runtime BYOK). Proxies the gateway's
       *     ``/admin/v1/provider-keys`` surface. The backend holds the
       *     gateway-key; the frontend never does. Returns a secret-safe status
       *     row per configured provider — the response NEVER contains a full
       *     key, only the last 4 characters of a resolved key. The caller's
       *     bearer token must have ``is_admin = true`` or the endpoint returns
       *     403 ``forbidden``.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Provider-key status list */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["ProviderKeyList"];
                  };
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      /**
       * Set/replace a provider's runtime key (admin only)
       * @description Proxies the gateway's set-key path. The gateway encrypts the
       *     plaintext key, persists it to gateway.yaml, and hot-applies the
       *     rebuilt adapter — no restart. The backend forwards the JSON and
       *     never returns the secret. 400 when the gateway master key is unset
       *     (surfaced as ``validation_error``); 404 when the provider isn't a
       *     configured entry.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["ProviderKeySetRequest"];
              };
          };
          responses: {
              /** @description Key applied; provider status returned (no secret) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["ProviderKeyStatus"];
                  };
              };
              /** @description Gateway master key is not set */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Provider not configured */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/provider-keys/{provider}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              provider: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /**
       * Revoke a provider's runtime key (admin only)
       * @description Proxies the gateway's revoke path. Only runtime
       *     (encrypted-at-rest) keys can be revoked; an env-sourced key is
       *     owned by the operator's environment and returns 409.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  provider: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Runtime key revoked */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Provider not configured */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Provider has no runtime key to revoke (e.g., env-sourced) */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      /**
       * Rotate a provider's runtime key (admin only)
       * @description Same mechanics as POST /api/v1/admin/provider-keys; the provider
       *     comes from the path. Proxies the gateway, which retires the
       *     displaced adapter and swaps the rebuilt one in. The backend never
       *     returns the secret. 400 when the gateway master key is unset; 404
       *     when the provider isn't configured.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  provider: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["ProviderKeyRotateRequest"];
              };
          };
          responses: {
              /** @description Key rotated; provider status returned (no secret) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["ProviderKeyStatus"];
                  };
              };
              /** @description Gateway master key is not set */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Provider not configured */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/admin/config": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Sanitized live gateway config (admin only)
       * @description Proxies the gateway's ``/admin/v1/config`` endpoint. Used by
       *     the web UI to populate the provider dropdown when editing
       *     aliases. Secrets are not in the schema; the payload contains
       *     env-var *names* only.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Sanitized config payload */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          [key: string]: unknown;
                      };
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/users": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List users for RBAC administration (Wave B v2 — PRD §5.2)
       * @description Admin-only. Returns the full list of non-deleted users with
       *     their role + auth state. Supports filtering by role, email
       *     substring search, and pagination. Default sort is email ASC.
       *     Used by /lq-ai/admin/developer's role-management card.
       */
      get: {
          parameters: {
              query?: {
                  role?: "admin" | "member" | "viewer";
                  email_q?: string;
                  limit?: number;
                  offset?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description User list (paginated) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AdminUserListResponse"];
                  };
              };
              /** @description Invalid role filter */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Caller is not admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/users/{user_id}/role": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              user_id: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      /**
       * Set a user's RBAC role (admin | member | viewer)
       * @description Wave C. Updates ``users.role`` and keeps ``is_admin`` in sync
       *     (True iff role='admin'). Idempotent: re-applying the same role
       *     returns 200 without an audit row. Real changes write a
       *     ``user.role_updated`` audit row with before/after values.
       *
       *     Lockout protection: refuses to demote the last admin in the
       *     deployment (409 — promote someone else first).
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  user_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      /** @enum {string} */
                      role: "admin" | "member" | "viewer";
                  };
              };
          };
          responses: {
              /** @description Updated role */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /** Format: uuid */
                          user_id: string;
                          /** Format: email */
                          email: string;
                          /** @enum {string} */
                          role: "admin" | "member" | "viewer";
                          is_admin: boolean;
                      };
                  };
              };
              /** @description Last-admin demotion lockout. */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Target user not found. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Invalid role value. */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/admin/tier-policy": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /** Get current Inference Tier policy */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Policy */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TierPolicy"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      /**
       * Partial update to Inference Tier policy
       * @description Admin-only. Audited. Partial-update semantics — fields omitted from
       *     the request body are left unchanged.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["TierPolicy"];
              };
          };
          responses: {
              /** @description Updated */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TierPolicy"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/admin/usage": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Cost + tokens aggregation across inference_routing_log
       * @description Admin-only. Aggregates ``inference_routing_log`` rows by one of
       *     user | provider | model | tier | day. Refusals are excluded by
       *     default (they didn't consume upstream tokens). Filters: date
       *     range + the same grouping dimensions. Returns per-group rows
       *     plus deployment-wide totals so the admin UI can render
       *     percentages without a second query.
       */
      get: {
          parameters: {
              query?: {
                  group_by?: "user" | "provider" | "model" | "tier" | "day";
                  date_from?: string;
                  date_to?: string;
                  user_id?: string;
                  provider?: string;
                  model?: string;
                  tier?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Aggregated usage rows + totals */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["UsageResponse"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/word-addin/manifest": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Render the Word add-in manifest XML for sideload (M3-B1)
       * @description Admin-only. Renders the Office Add-in XML manifest with the
       *     operator's deployment URL + a freshly generated GUID substituted
       *     into the template. Operators use the rendered file to sideload
       *     the add-in via Microsoft 365 Admin Center.
       *
       *     Origin resolution order:
       *     1. ``deployment_origin`` query param when supplied
       *     2. ``X-Forwarded-Proto`` + ``X-Forwarded-Host`` headers (the
       *        operator's reverse-proxy reports these)
       *     3. The request URL's scheme + host (single-process dev fallback)
       *
       *     Per PRD §9 DE-287, the Word add-in's user-facing feature tabs
       *     (chat / skills / playbook execution / Inference Tier badge) are
       *     descoped to M4 / community contribution; this M3-B1 endpoint
       *     ships the install-and-authenticate plumbing.
       */
      get: {
          parameters: {
              query?: {
                  /**
                   * @description Override the deployment origin embedded in the manifest.
                   *     Defaults to the request's effective origin (reverse-proxy
                   *     aware). No trailing slash.
                   */
                  deployment_origin?: string;
                  /**
                   * @description Branded name surfaced inside Word's ribbon and the task
                   *     pane GetStarted message.
                   */
                  display_name?: string;
                  /**
                   * @description ProviderName value the manifest surfaces to Microsoft 365
                   *     Admin Center; typically the operator org's name.
                   */
                  provider_name?: string;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Rendered Office Add-in XML manifest */
              200: {
                  headers: {
                      /** @description Tells the browser to download the manifest as a file. */
                      "Content-Disposition"?: string;
                      [name: string]: unknown;
                  };
                  content: {
                      "application/xml": string;
                  };
              };
              /** @description Unauthenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Caller is not an admin user */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/word-addin/version": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Word add-in version handshake (M3-B8)
       * @description **Unauthenticated.** The Word add-in's task pane calls this on
       *     mount, BEFORE the user has signed in, so an out-of-date add-in
       *     can surface an "Update needed" overlay rather than getting
       *     stuck at a broken OAuth handshake or a breaking-change API
       *     call.
       *
       *     Response payload:
       *     - `deployment_version` — the LQ.AI api package version (the
       *       deployment's release number). Informational; the add-in
       *       surfaces it in the "Update needed" overlay so a user can
       *       quote it to support.
       *     - `addin_min_compatible_version` / `addin_max_compatible_version`
       *       — the semver range of add-in bundles this deployment can
       *       talk to. The task pane refuses to render features outside
       *       the range.
       *     - `taskpane_bundle_url` — canonical URL of the task pane HTML
       *       entry. The task pane already knows this from `window.location`
       *       today; the field exists in the handshake so a future
       *       deployment can serve the bundle from a CDN or operator-chosen
       *       path without changing the manifest.
       *     - `taskpane_bundle_hash` — optional SHA-256 of the deployed
       *       bundle JS. M3-B8 ships this nullable; M3-B7 signing CI
       *       populates the value from the build manifest. Null means
       *       "don't enforce" — not an error.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Version handshake payload */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["WordAddinVersionResponse"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/inference/current-tier": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Derive routed tier for a (provider, model) pair
       * @description The Tier Awareness UI's click-for-details panel calls this so
       *     the user sees the human-readable tier label + the provider type
       *     the Provider Compliance Matrix renders against. 404 when the
       *     pair isn't in the gateway's model list.
       */
      get: {
          parameters: {
              query: {
                  provider: string;
                  model: string;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Current tier + explanation */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["CurrentTierResponse"];
                  };
              };
              /** @description No (provider, model) entry in the gateway's model list. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/inference/tier-config": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Operator's tier policy (deployment-level disclosure)
       * @description User-accessible read of allowed_tiers_global + the default /
       *     privileged minima. The admin write surface lives at
       *     ``PATCH /api/v1/admin/tier-policy``.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Tier policy snapshot */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TierConfigResponse"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/inference/override-tier-floor": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Re-run a refused inference with the tier floor lifted (admin only)
       * @description Wave D.1 T4. Admin-only override that re-runs the original user
       *     prompt with ``tier_floor=None`` for this turn. Looks up the
       *     ``kind='refusal'`` message at ``message_id``, finds the
       *     immediately preceding ``kind='user'`` message in the same chat,
       *     and forwards both to the gateway with no project floor and no
       *     per-call minimum. Persists a new ``kind='ai'`` ``Message`` row
       *     and writes an ``audit_log`` row with the operator-supplied
       *     ``reason``. Returns the new message + the routing-log row id
       *     the gateway wrote.
       *
       *     M1 binds to the ``is_admin`` role. Per-user
       *     ``override_tier_floor`` capability is deferred to v1.1+.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      /** Format: uuid */
                      message_id: string;
                      reason: string;
                  };
              };
          };
          responses: {
              /** @description Re-run completed; new ``kind='ai'`` message persisted. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          ai_message: components["schemas"]["Message"];
                          /** Format: uuid */
                          routing_log_id?: string | null;
                      };
                  };
              };
              /** @description Caller is not an admin. */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description ``message_id`` does not resolve to a refusal row. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/chats/{chat_id}/receipts": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Chronological event log for a chat (replay-at-read)
       * @description Wave D.1 T5 (spec §7.6). Merges chronological events from four
       *     source tables into a single timestamp-ordered stream:
       *
       *       * ``messages``                (``kind='message'``)
       *       * ``messages.applied_skills`` (one event per skill name; ``kind='skill'``)
       *       * ``inference_routing_log``   (``kind='inference'`` or ``kind='error'`` if ``refused=True``)
       *       * ``audit_log``               (``kind='audit'`` or ``kind='retrieval'`` if ``action='inference.kb_chunks_retrieved'``)
       *
       *     Owner-of-chat or admin only. Replay-at-read for M1 — chats are
       *     bounded (<100 events typical). A materialized ``chat_receipts``
       *     projection is a v1.1+ candidate if latency degrades.
       */
      get: {
          parameters: {
              query?: {
                  /**
                   * @description Comma-separated subset of: ``message``, ``inference``,
                   *     ``audit``, ``skill``, ``retrieval``, ``error``. Omit for
                   *     all kinds. Unknown tokens are silently ignored.
                   */
                  event_kinds?: string;
              };
              header?: never;
              path: {
                  chat_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Chronological list of receipt events, oldest first. */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          /** Format: date-time */
                          ts: string;
                          /** @enum {string} */
                          kind: "message" | "inference" | "audit" | "skill" | "retrieval" | "error";
                          detail: {
                              [key: string]: unknown;
                          };
                      }[];
                  };
              };
              /** @description Caller is not the chat owner or an admin. */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Chat not found. */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/chats/{chat_id}/receipts/export.jsonl": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /** Export receipts as JSONL (one event per line) */
      get: {
          parameters: {
              query?: {
                  /** @description Comma-separated subset (same as the JSON endpoint) */
                  event_kinds?: string;
              };
              header?: never;
              path: {
                  chat_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description JSONL stream — one event per line */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/jsonl": string;
                  };
              };
              /** @description Forbidden — not the owner or admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Chat not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/chats/{chat_id}/tool-calls/{pending_call_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /** Approve or deny a pending destructive chat tool-call; resumes the turn */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  chat_id: string;
                  pending_call_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["ToolCallDecisionRequest"];
              };
          };
          responses: {
              /** @description SSE stream — resumes the turn after approval or denial */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "text/event-stream": string;
                  };
              };
              /** @description Malformed request body */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Chat or pending tool-call not found (id-probing-safe) */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Tool-call already resolved or confirmation expired */
              409: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/integrations/slack/workspaces": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Persist a Slack workspace from the slack-bridge OAuth flow (M3-D1)
       * @description Service-to-service endpoint. Authenticated by a shared
       *     `Authorization: Bearer ${LQ_AI_BRIDGE_TOKEN}` token (NOT a user
       *     JWT) — the slack-bridge is the only intended caller.
       *
       *     The bridge POSTs the workspace tuple after the operator
       *     completes the Slack OAuth install flow at
       *     `${LQ_AI_BRIDGE_PUBLIC_URL}/slack/oauth/install`. The api
       *     encrypts the bot token at rest under `LQ_AI_BRIDGE_MASTER_KEY`
       *     (a separate Fernet master key from the gateway's
       *     `LQ_AI_GATEWAY_MASTER_KEY` — different threat models) and
       *     upserts on `team_id` so a re-install (Slack rotates bot tokens
       *     on re-install) replaces the old ciphertext + scope + installer
       *     in place. Soft-deleted rows revive on re-install.
       *
       *     500 (not 401) is the response when the operator hasn't set
       *     `LQ_AI_BRIDGE_TOKEN` on the api — accepting bridge traffic
       *     with no enforced secret would silently break the trust
       *     contract.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["SlackWorkspaceCreate"];
              };
          };
          responses: {
              /** @description Persisted (or upserted) the workspace record */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["SlackWorkspaceResponse"];
                  };
              };
              /** @description Missing, malformed, or non-matching bridge bearer token */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Operator has not configured `LQ_AI_BRIDGE_TOKEN` on the api */
              500: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/integrations/teams/tenants": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Persist a Microsoft 365 tenant from the teams-bridge OAuth flow (M3-D3)
       * @description Service-to-service endpoint. Authenticated by the **same**
       *     `Authorization: Bearer ${LQ_AI_BRIDGE_TOKEN}` bearer as the
       *     slack-bridge endpoint per M3-D3 decision #2 — one shared
       *     secret authenticates every bridge → api call.
       *
       *     Unlike the Slack equivalent, no bot token is persisted here:
       *     Microsoft Teams uses operator-supplied APP-LEVEL bot
       *     credentials (one `MICROSOFT_APP_ID` per deployment) not
       *     per-tenant tokens. The persisted record carries only the
       *     tenant id + display name + installer object id.
       *
       *     Upserts on `tenant_id`. Soft-deleted rows revive on
       *     re-install. `installed_at` is NOT moved by upsert (operators
       *     can infer re-install activity from other field changes).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["TeamsTenantCreate"];
              };
          };
          responses: {
              /** @description Persisted (or upserted) the tenant record */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["TeamsTenantResponse"];
                  };
              };
              /** @description Missing, malformed, or non-matching bridge bearer token */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Operator has not configured `LQ_AI_BRIDGE_TOKEN` on the api */
              500: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/intake-bridges": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List live Slack + Teams installs for the admin UI (M3-D4)
       * @description Returns non-soft-deleted Slack workspaces and Teams tenants,
       *     sorted by `installed_at DESC` within each section. Admin-only.
       *     Backs the SvelteKit admin page at `/lq-ai/admin/intake-bridges`.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Live install list */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["IntakeBridgesList"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Authenticated but not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/intake-bridges/slack/{workspace_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /**
       * Soft-delete a Slack workspace install (M3-D4)
       * @description Sets `deleted_at` to now. The row stays in the DB so a
       *     re-install via the slack-bridge OAuth flow revives it in
       *     place per the M3-D1 upsert semantics; the install history
       *     is preserved across disconnect/reconnect cycles.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  workspace_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Soft-deleted */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Authenticated but not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Workspace not found or already disconnected */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/intake-bridges/teams/{tenant_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /**
       * Soft-delete a Microsoft 365 tenant install (M3-D4)
       * @description Same posture as the Slack endpoint above — soft-delete with
       *     revivable row.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  tenant_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Soft-deleted */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Authenticated but not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Tenant not found or already disconnected */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/sessions": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the calling user's autonomous sessions (newest first, paginated)
       * @description Returns the caller's sessions ordered by ``created_at DESC``.
       *     ``limit`` is clamped to [1, 200]; ``offset`` to [0, ∞).
       *     Only the caller's own sessions are returned — cross-user isolation
       *     is enforced at the query level.
       */
      get: {
          parameters: {
              query?: {
                  /** @description Maximum number of sessions to return (clamped to [1, 200]). */
                  limit?: number;
                  /** @description Zero-based index of the first result to return. */
                  offset?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated list of autonomous sessions */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousSessionListResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/sessions/{session_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Fetch a single autonomous session with its full receipt
       * @description Returns the session plus a live-reconstructed receipt built from
       *     audit rows (works for running and completed sessions).  A completed
       *     session also has the receipt persisted in ``result``.
       *
       *     Another user's ``session_id`` returns 404 (not 403) to avoid
       *     existence disclosure.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  session_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Session detail with receipt */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousSessionDetailResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Session not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/sessions/{session_id}/findings": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List a session's persisted findings (work-product, stable order)
       * @description Returns the run's persisted findings (the ``emit_finding`` chokepoint
       *     work-product) ordered by ``created_at ASC, id ASC``. Rows a run
       *     emits in its single executor commit typically share one
       *     ``created_at`` (transaction-stable ``now()``), so ``id`` is the
       *     deterministic tiebreaker that keeps pagination stable — a
       *     repeatable order, not a guaranteed emission sequence. This differs
       *     intentionally from the newest-first autonomous lists: these are one
       *     run's output.
       *
       *     Owner-gated by loading the owned session first (the findings table
       *     has no ``user_id`` — authz is via the parent session). Another
       *     user's ``session_id`` — or a missing one — returns 404 (not 403) to
       *     avoid existence disclosure. ``limit`` is clamped to [1, 200];
       *     ``offset`` to [0, ∞).
       */
      get: {
          parameters: {
              query?: {
                  /** @description Maximum number of findings to return (clamped to [1, 200]). */
                  limit?: number;
                  /** @description Zero-based index of the first result to return. */
                  offset?: number;
              };
              header?: never;
              path: {
                  session_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated list of the session's findings (stable created_at, id order) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousFindingListResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Session not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/sessions/{session_id}/artifacts": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List a session's persisted document-grade artifacts (work-product, stable order)
       * @description Returns the run's persisted artifact references (the
       *     ``emit_artifact`` chokepoint work-product — markdown memos an
       *     opted-in run saved into its target knowledge base as real
       *     documents) ordered by ``created_at ASC, id ASC`` — one run's rows
       *     typically share ``created_at`` (transaction-stable ``now()``), so
       *     ``id`` is the deterministic tiebreaker that keeps pagination
       *     stable; a repeatable order, not a guaranteed emission sequence.
       *     Mirrors the findings read above.
       *
       *     Owner-gated by loading the owned session first (the artifacts
       *     table has no ``user_id`` — authz is via the parent session).
       *     Another user's ``session_id`` — or a missing one — returns 404
       *     (not 403) to avoid existence disclosure. ``limit`` is clamped to
       *     [1, 200]; ``offset`` to [0, ∞).
       *
       *     ``document_id`` is enriched at read time via the unique
       *     ``documents.file_id``. Deletion semantics: a hard file-delete
       *     SET-NULLs ``file_id`` (name/size metadata survives; both refs
       *     return null); deleting the session removes these reference rows
       *     but never the KB document — the document outlives the session.
       */
      get: {
          parameters: {
              query?: {
                  /** @description Maximum number of artifacts to return (clamped to [1, 200]). */
                  limit?: number;
                  /** @description Zero-based index of the first result to return. */
                  offset?: number;
              };
              header?: never;
              path: {
                  session_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated list of the session's artifact references (stable created_at, id order) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousArtifactListResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Session not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/sessions/{session_id}/halt": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Request an immediate halt for an autonomous session (idempotent)
       * @description Sets ``halt_state = 'halt_requested'`` so the executor's R5 temporal
       *     brake trips on the next tool call and transitions the session to
       *     ``halted``.
       *
       *     **Idempotent:** if ``halt_state`` is already ``halt_requested`` or
       *     ``halted``, the endpoint returns the current session state with 200
       *     and writes no duplicate audit row.
       *
       *     Another user's ``session_id`` returns 404 (not 403).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  session_id: string;
              };
              cookie?: never;
          };
          requestBody?: {
              content: {
                  "*/*"?: never;
              };
          };
          responses: {
              /** @description Updated session (halt requested or already halted) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousSessionRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Session not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/memory": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the calling user's autonomous memory entries (non-deleted, newest first)
       * @description Returns the caller's non-deleted memory entries ordered by
       *     ``created_at DESC``.  Pass ``?state=proposed|kept|dismissed`` to
       *     filter by review state; omitting ``state`` returns all non-deleted
       *     entries.  ``limit`` is clamped to [1, 200]; ``offset`` to [0, ∞).
       */
      get: {
          parameters: {
              query?: {
                  /** @description Filter by review state; omit to return all non-deleted entries. */
                  state?: "proposed" | "kept" | "dismissed";
                  /** @description Narrow to the memories a specific run proposed; omit for all. */
                  source_session_id?: string;
                  /** @description Maximum number of entries to return (clamped to [1, 200]). */
                  limit?: number;
                  /** @description Zero-based index of the first result to return. */
                  offset?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated list of autonomous memory entries */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousMemoryListResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/memory/{memory_id}/keep": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Keep (approve) an autonomous memory entry; optional edit-on-keep
       * @description Transitions ``proposed`` or ``dismissed`` → ``kept``.  If the
       *     optional body supplies ``content``, the entry's text is overwritten
       *     (edit-on-keep).
       *
       *     **Re-keep semantics:** if the entry is already ``kept``, the action
       *     is allowed — content is updated if provided; ``kept_at`` is
       *     preserved.
       *
       *     Another user's ``memory_id`` returns 404.  Audited.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  memory_id: string;
              };
              cookie?: never;
          };
          requestBody?: {
              content: {
                  "application/json": components["schemas"]["MemoryKeepRequest"];
              };
          };
          responses: {
              /** @description Updated memory entry (now kept) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousMemoryRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Memory entry not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/memory/{memory_id}/dismiss": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Dismiss an autonomous memory entry
       * @description Transitions ``proposed`` or ``kept`` → ``dismissed``.
       *
       *     Another user's ``memory_id`` returns 404.  Audited.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  memory_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Updated memory entry (now dismissed) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousMemoryRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Memory entry not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/memory/{memory_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /**
       * Soft-delete an autonomous memory entry (returns 200 with updated entry)
       * @description Soft-deletes the entry by setting ``deleted_at=now(UTC)``.
       *     Returns **200** with the updated (deleted) entry — not 204 — to
       *     avoid the FastAPI JSONResponse/204 assertion pitfall.
       *
       *     A subsequent GET excludes the entry; keep/dismiss/delete on a
       *     deleted entry return 404.
       *
       *     Another user's ``memory_id`` returns 404.  Audited.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  memory_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Soft-deleted memory entry */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousMemoryRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Memory entry not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/precedents": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the calling user's precedent entries (non-dismissed, newest first)
       * @description Returns the caller's non-dismissed precedent entries
       *     (``dismissed_at IS NULL``) ordered by ``created_at DESC``.  Pass
       *     ``?pattern_kind=`` to filter to one classifier; omitting it returns
       *     all non-dismissed entries.  ``limit`` is clamped to [1, 200];
       *     ``offset`` to [0, ∞).
       */
      get: {
          parameters: {
              query?: {
                  /** @description Filter by precedent classifier; omit to return all non-dismissed entries. */
                  pattern_kind?: string;
                  /** @description Maximum number of entries to return (clamped to [1, 200]). */
                  limit?: number;
                  /** @description Zero-based index of the first result to return. */
                  offset?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated list of precedent entries */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["PrecedentEntryListResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/precedents/{precedent_id}/dismiss": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Dismiss a precedent entry (idempotent)
       * @description Sets ``dismissed_at=now(UTC)`` so the entry drops out of the board.
       *     Re-dismissing leaves the original ``dismissed_at`` untouched.
       *
       *     Another user's ``precedent_id`` returns 404.  Audited.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  precedent_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Updated precedent entry (now dismissed) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["PrecedentEntryRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Precedent entry not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/precedents/{precedent_id}/promote": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Propose promoting a precedent into a Project's context (proposal only)
       * @description Creates a ``proposed`` project-context proposal linking the
       *     precedent to ``project_id``.  The ``suggested_md`` snippet is
       *     derived server-side from the precedent's ``summary``.
       *
       *     This endpoint does **NOT** mutate ``projects.context_md`` —
       *     promotion is a proposal only; the user accepting it performs the
       *     authorized write (ADR 0013 D5).
       *
       *     Another user's ``precedent_id`` — or a ``project_id`` the caller
       *     does not own — returns 404.  Audited.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  precedent_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["PromotePrecedentRequest"];
              };
          };
          responses: {
              /** @description Proposal created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["ProjectContextProposalRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Precedent or target project not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/project-context-proposals": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the calling user's project-context proposals (newest first)
       * @description Returns the caller's project-context proposals ordered by
       *     ``created_at DESC``.  Pass ``?state=proposed|accepted|rejected``
       *     and/or ``?project_id=`` to filter.  ``limit`` is clamped to
       *     [1, 200]; ``offset`` to [0, ∞).
       */
      get: {
          parameters: {
              query?: {
                  /** @description Filter by proposal state. */
                  state?: "proposed" | "accepted" | "rejected";
                  /** @description Filter to proposals targeting one Project. */
                  project_id?: string;
                  /** @description Maximum number of proposals to return (clamped to [1, 200]). */
                  limit?: number;
                  /** @description Zero-based index of the first result to return. */
                  offset?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated list of project-context proposals */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["ProjectContextProposalListResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/project-context-proposals/{proposal_id}/accept": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Accept a proposal — append the suggested context to the Project (user-authorized write)
       * @description The user-authorized write (ADR 0013 D5): appends the proposal's
       *     ``suggested_md`` to the target Project's ``context_md``
       *     (initializing it if NULL), sets ``state='accepted'`` and
       *     ``accepted_at``.
       *
       *     Idempotent on re-accept: if already ``accepted``, returns the
       *     current state without re-appending.  A ``rejected`` proposal may be
       *     accepted (rejected→accepted) and the append occurs.
       *
       *     Another user's ``proposal_id`` returns 404.  Audited.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  proposal_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Updated proposal (now accepted) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["ProjectContextProposalRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Proposal not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/project-context-proposals/{proposal_id}/reject": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Reject a proposal (does not touch Project context)
       * @description Sets ``state='rejected'`` and ``rejected_at``.  Does NOT touch
       *     ``projects.context_md``.
       *
       *     Another user's ``proposal_id`` returns 404.  Audited.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  proposal_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Updated proposal (now rejected) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["ProjectContextProposalRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Proposal not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/schedules": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the calling user's autonomous schedules (non-deleted, newest first)
       * @description Returns the caller's non-deleted schedules ordered by
       *     ``created_at DESC``.  Optional ``?enabled=`` filter.
       */
      get: {
          parameters: {
              query?: {
                  enabled?: boolean;
                  limit?: number;
                  offset?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated list of schedules */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousScheduleListResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      /**
       * Create an autonomous schedule (cron-triggered run definition)
       * @description Validates ``cron_expr`` (a five-field cron string); invalid
       *     expressions return 422.  Seeds ``next_run_at`` from the cron
       *     expression so the dispatcher can pick it up.  Per-user isolated.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["AutonomousScheduleCreate"];
              };
          };
          responses: {
              /** @description Schedule created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousScheduleRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Referenced project not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Invalid cron expression */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/schedules/{schedule_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /**
       * Soft-delete an autonomous schedule (returns 200 with updated entity)
       * @description Soft-deletes by setting ``deleted_at``.  Returns 200 with the
       *     updated entity (NOT 204 — FastAPI JSONResponse/204 pitfall).
       *     A deleted schedule is excluded from list and the dispatcher;
       *     re-delete returns 404.  Another user's ``schedule_id`` returns 404.
       *     Audited.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  schedule_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Updated schedule (now soft-deleted) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousScheduleRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Schedule not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      /**
       * Partially update an autonomous schedule (edit / enable / disable)
       * @description Partial update.  If ``cron_expr`` changes it is re-validated (422
       *     on invalid) and ``next_run_at`` is recomputed.  Another user's
       *     ``schedule_id`` returns 404.  Audited.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  schedule_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["AutonomousScheduleUpdate"];
              };
          };
          responses: {
              /** @description Updated schedule */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousScheduleRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Schedule or referenced project not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Invalid cron expression */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      trace?: never;
  };
  "/api/v1/autonomous/watches": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the calling user's autonomous watches (non-deleted, newest first)
       * @description Returns the caller's non-deleted watches ordered by
       *     ``created_at DESC``.  Optional ``?enabled=`` and
       *     ``?knowledge_base_id=`` filters.
       */
      get: {
          parameters: {
              query?: {
                  enabled?: boolean;
                  knowledge_base_id?: string;
                  limit?: number;
                  offset?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated list of watches */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousWatchListResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      /**
       * Create an autonomous watch (KB-arrival-triggered run definition)
       * @description Creates a watch on a knowledge base the caller owns; document
       *     arrivals (KB attach) then spawn an autonomous session. The caller
       *     must own the target ``knowledge_base_id`` — a KB they cannot see
       *     returns 404 (KB-sharing is out of scope). Per-user isolated.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["AutonomousWatchCreate"];
              };
          };
          responses: {
              /** @description Watch created */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousWatchRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Target knowledge base or referenced project not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/watches/{watch_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /**
       * Soft-delete an autonomous watch (returns 200 with updated entity)
       * @description Soft-deletes by setting ``deleted_at``.  Returns 200 with the
       *     updated entity (NOT 204 — FastAPI JSONResponse/204 pitfall).
       *     A deleted watch is excluded from list and the KB-arrival trigger;
       *     re-delete returns 404.  Another user's ``watch_id`` returns 404.
       *     Audited.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  watch_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Updated watch (now soft-deleted) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousWatchRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Watch not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      options?: never;
      head?: never;
      /**
       * Partially update an autonomous watch (enable / disable / retarget)
       * @description Partial update of ``enabled`` / ``playbook_id`` / ``skill_ref``.
       *     The watch's ``knowledge_base_id`` is immutable. Another user's
       *     ``watch_id`` returns 404.  Audited.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  watch_id: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["AutonomousWatchUpdate"];
              };
          };
          responses: {
              /** @description Updated watch */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousWatchRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Watch or referenced project not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      trace?: never;
  };
  "/api/v1/autonomous/notifications": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List the calling user's autonomous notifications (newest first)
       * @description Returns the caller's notifications ordered by ``created_at DESC``.
       *     Pass ``?unread=true`` to narrow to unread rows (``read_at IS
       *     NULL``). Per-user isolated.
       */
      get: {
          parameters: {
              query?: {
                  unread?: boolean;
                  limit?: number;
                  offset?: number;
              };
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Paginated list of notifications */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousNotificationListResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/notifications/{notification_id}/read": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Mark an autonomous notification read (the dismiss action; idempotent)
       * @description Sets ``read_at`` if currently NULL; idempotent (re-read preserves
       *     the original timestamp). "Read" IS the dismiss action — a read
       *     notification drops out of ``?unread=true``. Another user's
       *     ``notification_id`` returns 404.  Audited.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  notification_id: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Updated notification (now read) */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousNotificationRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Notification not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/autonomous/run-now": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Run a skill or playbook once now (one-off manual autonomous session)
       * @description Spawns a single ``trigger_kind='manual'`` autonomous session so a
       *     user can test what a skill/playbook does — and inspect the
       *     resulting receipt — before arming it as a schedule or watch.
       *     Exactly one of ``playbook_id`` / ``skill_ref`` must be set (zero
       *     or both → 422). ``target_kb_id`` / ``project_id`` are optional
       *     scope; ``max_cost_usd`` is the per-run cap (NULL falls back to the
       *     config default so R4 always arms). Gated by opt-in
       *     (``autonomous_enabled``); the spawned session runs under the same
       *     R4/R5/R6 brakes as every other session. Per-user isolated. Audited.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["AutonomousManualRunRequest"];
              };
          };
          responses: {
              /** @description Session spawned */
              201: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["AutonomousSessionRead"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Autonomous layer not enabled for this user */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Referenced project not found */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Invalid target (need exactly one of playbook_id/skill_ref) */
              422: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/research/capabilities": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Report whether case-law research is enabled on this server
       * @description WS3b. Returns a positive "research enabled?" signal derived from the
       *     gateway's sanitised config.  ``enabled`` is ``true`` when at least one
       *     ``courtlistener`` tool-provider is declared in ``gateway.yaml``;
       *     ``false`` otherwise.  The UI uses this to render a calm "not configured"
       *     gate rather than treating an absent CourtListener as an outage.
       *     Requires an authenticated user (bearer token).
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Research capability status */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          enabled: boolean;
                          providers: {
                              name: string;
                              type: string;
                          }[];
                      };
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/research/verify-citations": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Verify citations found in a text block
       * @description WS3b. Passes the supplied text to the CourtListener gateway tool
       *     ``verify_citations`` and returns the per-citation verification
       *     results (HTTP status, matching cluster ids). Stateless — no DB
       *     write. Requires an authenticated user (bearer token).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      text: string;
                  };
              };
          };
          responses: {
              /** @description Citation verification results */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          citations?: {
                              citation?: string | null;
                              normalized_citations?: string[];
                              status?: number | null;
                              error_message?: string | null;
                              clusters?: {
                                  id?: number | null;
                                  case_name?: string | null;
                                  absolute_url?: string | null;
                              }[];
                          }[];
                      };
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/research/search": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Search case law via CourtListener
       * @description WS3b. Proxies a full-text case-law search to the CourtListener
       *     gateway tool ``search_case_law``. Returns a paginated result set
       *     with case metadata. Stateless — no DB write. Requires an
       *     authenticated user (bearer token).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      q: string;
                      court?: string | null;
                      order_by?: string | null;
                      /** @description Opaque pagination cursor from a prior response's next_cursor; fetch the next page. */
                      cursor?: string | null;
                  };
              };
          };
          responses: {
              /** @description Search results */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          count?: number | null;
                          results?: {
                              [key: string]: unknown;
                          }[];
                          next_cursor?: string | null;
                      };
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/research/clusters/{cluster_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Fetch and cache a CourtListener opinion cluster
       * @description WS3b. Read-through cache: if the cluster is already in the DB
       *     the cached metadata is returned immediately; otherwise the
       *     gateway tool ``get_cases`` is called, the opinion plaintext is
       *     stored in object storage, and the metadata is persisted in the
       *     DB. Requires an authenticated user (bearer token).
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  cluster_id: number;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Cluster metadata with opinion list */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          cluster: {
                              cluster_id: number;
                              case_name?: string | null;
                              court?: string | null;
                              date_filed?: string | null;
                              absolute_url?: string | null;
                          };
                          opinions: {
                              opinion_id: number;
                              /** @enum {string|null} */
                              text_field_used?: "html_with_citations" | "html_columbia" | "html_lawbox" | "xml_harvard" | "html_anon_2020" | "html" | "plain_text" | null;
                              char_length: number;
                          }[];
                      };
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/research/opinions/{opinion_id}": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * Read cached opinion plaintext
       * @description WS3b. Returns the full plaintext of a previously fetched opinion
       *     from object storage. Returns 404 if the cluster containing this
       *     opinion was never fetched (call
       *     ``GET /api/v1/research/clusters/{cluster_id}`` first). Requires
       *     an authenticated user (bearer token).
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  opinion_id: number;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Opinion plaintext */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          opinion_id: number;
                          cluster_id: number;
                          /** @enum {string|null} */
                          text_field_used?: "html_with_citations" | "html_columbia" | "html_lawbox" | "xml_harvard" | "html_anon_2020" | "html" | "plain_text" | null;
                          text: string;
                      };
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Opinion not yet fetched; call GET /clusters/{id} first */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/research/find-in-case": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Find keyword matches within a cached opinion
       * @description WS3b. Performs a case-insensitive substring search over the
       *     cached plaintext of ``opinion_id``, returning up to
       *     ``max_matches`` snippets with character positions. Returns 404
       *     if the opinion was never fetched. Requires an authenticated
       *     user (bearer token).
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": {
                      opinion_id: number;
                      query: string;
                      /** @default 3 */
                      max_matches?: number;
                  };
              };
          };
          responses: {
              /** @description Match snippets */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": {
                          opinion_id: number;
                          matches: {
                              position: number;
                              snippet: string;
                          }[];
                      };
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Opinion not yet fetched; call GET /clusters/{id} first */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/mcp": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List configured MCP servers and their cached tools (admin only)
       * @description WS2/PR4b. Returns the operator's configured MCP servers (sourced
       *     from gateway config, type==mcp) together with each server's
       *     discovery-cached tools and their ``enabled`` toggle state. The
       *     caller's bearer token must have ``is_admin = true`` or the
       *     endpoint returns 403 ``forbidden``.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description MCP servers with cached tools */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["MCPServersResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/mcp/{server}/refresh": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              /** @description MCP server name (as returned by the gateway config). */
              server: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      /**
       * Re-discover and reconcile a server's tools (admin only)
       * @description WS2/PR4b. Triggers a fresh tool-discovery pass against the named
       *     MCP server through the gateway (PR4a's GET /v1/tools/{provider}).
       *     The discovery cache is reconciled: new tools are inserted with
       *     ``enabled=true``; surviving tools preserve their existing
       *     ``enabled`` flag; stale tools (no longer returned) are removed.
       *     Writes a ``mcp.tools_refreshed`` audit row. 403 when the caller
       *     is not an admin.
       */
      post: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  /** @description MCP server name (as returned by the gateway config). */
                  server: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Refresh complete; returns the updated tool list */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["MCPRefreshResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/admin/mcp/{server}/tools/{tool}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              /** @description MCP server name. */
              server: string;
              /** @description Tool name within the server's discovery cache. */
              tool: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      /**
       * Enable or disable a cached MCP tool (admin only)
       * @description WS2/PR4b. Toggles the ``enabled`` flag on a single cached tool.
       *     Disabled tools are not exposed to the model in the chat tool-loop
       *     (PR5). 404 when the tool is not in the discovery cache (run
       *     ``POST .../refresh`` first). Writes a ``mcp.tool_enabled`` audit
       *     row when enabling, ``mcp.tool_disabled`` when disabling. 403 when
       *     the caller is not an admin.
       */
      patch: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  /** @description MCP server name. */
                  server: string;
                  /** @description Tool name within the server's discovery cache. */
                  tool: string;
              };
              cookie?: never;
          };
          requestBody: {
              content: {
                  "application/json": components["schemas"]["MCPToolEnableRequest"];
              };
          };
          responses: {
              /** @description Tool updated; returns the updated tool view */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["MCPToolView"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Caller is not an admin */
              403: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Tool not in discovery cache */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      trace?: never;
  };
  "/api/v1/mcp/oauth": {
      parameters: {
          query?: never;
          header?: never;
          path?: never;
          cookie?: never;
      };
      /**
       * List OAuth connection status for all connectable MCP servers (per-user)
       * @description PR4d Ask 1. ActiveUser-gated (bearer). Returns one entry per
       *     configured OAuth-type MCP server together with the calling user's
       *     connection state (``connected``, ``scopes``, ``expires_at``).
       *     Token bytes are never exposed. Results are ordered by server name
       *     for stable output.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path?: never;
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Per-user OAuth connection list */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["MCPOAuthServersResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/mcp/oauth/{server}/authorize": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              /** @description MCP server name (as returned by the gateway config). */
              server: string;
          };
          cookie?: never;
      };
      /**
       * Start the per-user OAuth flow for an MCP server
       * @description PR4c. ActiveUser-gated (bearer). Mints PKCE state, persists a
       *     single-use mcp_oauth_state row, and returns a 302 redirect to the
       *     authorization server's authorize endpoint. The callback URL is
       *     wired to GET /api/v1/mcp/oauth/{server}/callback.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  /** @description MCP server name (as returned by the gateway config). */
                  server: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Redirect to the authorization server authorize endpoint */
              302: {
                  headers: {
                      /** @description Authorization server authorize URL with PKCE parameters. */
                      Location?: string;
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Server is not a configured OAuth MCP provider */
              404: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/mcp/oauth/{server}/callback": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              /** @description MCP server name. */
              server: string;
          };
          cookie?: never;
      };
      /**
       * OAuth callback — receive the authorization code from the AS
       * @description PR4c. PUBLIC (no bearer auth). The browser is redirected here by
       *     the authorization server after the user grants consent. The caller
       *     is identified via the single-use, TTL-bounded mcp_oauth_state row
       *     (``state`` IS the binding). On success, tokens are encrypted and
       *     stored and a mcp.oauth_connected audit row is written. Returns 200
       *     with the connection summary.
       */
      get: {
          parameters: {
              query: {
                  /** @description Authorization code issued by the AS. */
                  code: string;
                  /** @description Opaque state value echoed from the authorize request. */
                  state: string;
                  /** @description Issuer identifier (RFC 9207); required when the AS advertised support. */
                  iss?: string;
              };
              header?: never;
              path: {
                  /** @description MCP server name. */
                  server: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description OAuth flow completed; tokens stored */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["MCPOAuthCallbackResponse"];
                  };
              };
              /** @description Unknown, expired, or replayed state; iss validation failure */
              400: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
              /** @description Authorization server returned an error on code exchange */
              502: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/mcp/oauth/{server}/status": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              /** @description MCP server name. */
              server: string;
          };
          cookie?: never;
      };
      /**
       * Check the calling user's OAuth connection state for an MCP server
       * @description PR4c. ActiveUser-gated (bearer). Returns whether a stored token
       *     exists for the (user, server) pair, the granted scopes, and the
       *     token expiry. Token bytes are never exposed.
       */
      get: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  /** @description MCP server name. */
                  server: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Connection status */
              200: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["MCPOAuthStatusResponse"];
                  };
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      put?: never;
      post?: never;
      delete?: never;
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
  "/api/v1/mcp/oauth/{server}": {
      parameters: {
          query?: never;
          header?: never;
          path: {
              /** @description MCP server name. */
              server: string;
          };
          cookie?: never;
      };
      get?: never;
      put?: never;
      post?: never;
      /**
       * Revoke the calling user's stored OAuth tokens for an MCP server
       * @description PR4c. ActiveUser-gated (bearer). Deletes the stored (user, server)
       *     token row. Idempotent — returns 204 even when no token was stored.
       *     AS-side revocation (RFC 7009) is not called in v1 (DE filed).
       *     Writes a mcp.oauth_disconnected audit row when a row was removed.
       */
      delete: {
          parameters: {
              query?: never;
              header?: never;
              path: {
                  /** @description MCP server name. */
                  server: string;
              };
              cookie?: never;
          };
          requestBody?: never;
          responses: {
              /** @description Token deleted (or was not present) */
              204: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content?: never;
              };
              /** @description Not authenticated */
              401: {
                  headers: {
                      [name: string]: unknown;
                  };
                  content: {
                      "application/json": components["schemas"]["Error"];
                  };
              };
          };
      };
      options?: never;
      head?: never;
      patch?: never;
      trace?: never;
  };
9674}
9675export type webhooks = Record<string, never>;
9676export interface components {
  schemas: {
      /**
       * @description Request body for `POST /api/v1/integrations/slack/workspaces`
       *     (M3-D1). Shape matches what `slack-bridge/app/oauth.py`
       *     constructs from Slack's `oauth.v2.access` response after the
       *     operator completes consent. The bridge → api contract is
       *     position-coupled to this shape; renames here would break it.
       */
      SlackWorkspaceCreate: {
          /**
           * @description Slack workspace id (T0...).
           * @example T01234567
           */
          team_id: string;
          /**
           * @description Workspace display name at install time.
           * @example Acme Legal
           */
          team_name: string;
          /**
           * @description The xoxb- bot user OAuth token Slack returned. Plaintext
           *     on the wire (the request travels over the trusted
           *     in-cluster network with a bridge bearer token); encrypted
           *     under `LQ_AI_BRIDGE_MASTER_KEY` before persistence.
           * @example xoxb-...
           */
          bot_token: string;
          /**
           * @description Slack user id of the bot user.
           * @example U99BOT
           */
          bot_user_id: string;
          /**
           * @description Slack user id of the operator who completed install (audit only).
           * @example U11INSTALLER
           */
          installer_slack_user_id: string;
          /**
           * @description Comma-separated scope list Slack returned.
           * @example commands,chat:write
           */
          scope: string;
      };
      /**
       * @description Request body for `POST /api/v1/integrations/teams/tenants`
       *     (M3-D3). Shape matches what `teams-bridge/app/oauth.py`
       *     constructs from the Microsoft id_token claims (`tid`, `oid`)
       *     + a best-effort Microsoft Graph `/organization` display-name
       *     lookup.
       */
      TeamsTenantCreate: {
          /**
           * @description Microsoft tenant id (`tid` claim — the M365 directory GUID).
           * @example 00000000-0000-0000-0000-aaaaaaaaaaaa
           */
          tenant_id: string;
          /**
           * @description Tenant display name at install time. Best-effort from
           *     Microsoft Graph `/organization`; falls back to the
           *     tenant_id if Graph errors.
           * @example Acme Legal LLP
           */
          tenant_name: string;
          /**
           * @description M365 `oid` claim of the admin who completed consent.
           *     Audit only — does not grant LQ.AI permissions.
           * @example 00000000-0000-0000-0000-111111111111
           */
          installer_oid: string;
      };
      /**
       * @description Persisted-tenant response for `POST
       *     /api/v1/integrations/teams/tenants`. Mirrors
       *     `SlackWorkspaceResponse` minus the per-tenant bot fields
       *     (Teams uses app-level credentials).
       */
      TeamsTenantResponse: {
          /**
           * Format: uuid
           * @description api-side tenant row id.
           */
          id: string;
          /** @example 00000000-0000-0000-0000-aaaaaaaaaaaa */
          tenant_id: string;
          /** @example Acme Legal LLP */
          tenant_name: string;
          /** @example 00000000-0000-0000-0000-111111111111 */
          installer_oid: string;
          /**
           * Format: date-time
           * @description Original install timestamp. NOT moved by upsert.
           */
          installed_at: string;
      };
      /**
       * @description One live Slack workspace row in the admin intake-bridges list
       *     (M3-D4). The wire shape mirrors the model row minus the bot
       *     token ciphertext (which the admin UI has no business seeing).
       */
      SlackWorkspaceSummary: {
          /** Format: uuid */
          id: string;
          team_id: string;
          team_name: string;
          installer_slack_user_id: string;
          /** Format: date-time */
          installed_at: string;
      };
      /**
       * @description One live Microsoft 365 tenant row in the admin intake-bridges
       *     list (M3-D4). Mirrors the model row.
       */
      TeamsTenantSummary: {
          /** Format: uuid */
          id: string;
          tenant_id: string;
          tenant_name: string;
          installer_oid: string;
          /** Format: date-time */
          installed_at: string;
      };
      /**
       * @description Section-split response for `GET /api/v1/admin/intake-bridges`.
       *     Separate sections (rather than a single polymorphic list) so
       *     the SvelteKit admin page renders two distinct sections without
       *     client-side discriminator-key gymnastics.
       */
      IntakeBridgesList: {
          slack_workspaces: components["schemas"]["SlackWorkspaceSummary"][];
          teams_tenants: components["schemas"]["TeamsTenantSummary"][];
      };
      /**
       * @description Persisted-workspace response for `POST
       *     /api/v1/integrations/slack/workspaces`. Bot token is
       *     deliberately omitted — neither the plaintext nor the
       *     ciphertext is echoed back to the bridge.
       */
      SlackWorkspaceResponse: {
          /**
           * Format: uuid
           * @description api-side workspace row id.
           */
          id: string;
          /** @example T01234567 */
          team_id: string;
          /** @example Acme Legal */
          team_name: string;
          /** @example U99BOT */
          bot_user_id: string;
          /** @example U11INSTALLER */
          installer_slack_user_id: string;
          /** @example commands,chat:write */
          scope: string;
          /**
           * Format: date-time
           * @description Original install timestamp. NOT moved by upsert.
           */
          installed_at: string;
      };
      /**
       * @description Response payload for `GET /api/v1/word-addin/version` (M3-B8).
       *     Consumed by the task pane on mount to decide whether the
       *     installed add-in version is compatible with this deployment.
       */
      WordAddinVersionResponse: {
          /**
           * @description LQ.AI deployment version (the api package `__version__`).
           *     Informational — the add-in surfaces it in the "Update
           *     needed" overlay so users can quote it to support.
           * @example 0.3.0
           */
          deployment_version: string;
          /**
           * @description Lowest add-in version (semver string) this deployment
           *     accepts. The task pane refuses to render features when
           *     its bundled version is lower.
           * @example 0.3.0
           */
          addin_min_compatible_version: string;
          /**
           * @description Highest add-in version this deployment recognizes. Bundles
           *     newer than this still load (forward compatibility is
           *     best-effort) but the add-in surfaces a soft warning so the
           *     operator knows to update the deployment.
           * @example 0.3.99
           */
          addin_max_compatible_version: string;
          /**
           * Format: uri
           * @description Canonical URL of the task pane bundle's HTML entry point.
           * @example https://lq.acme.example/word-addin/taskpane.html
           */
          taskpane_bundle_url: string;
          /**
           * @description Optional SHA-256 hash of the deployed task pane bundle JS.
           *     M3-B8 ships nullable; M3-B7 signing CI populates the value.
           *     Null means "don't enforce" — not an error.
           * @example null
           */
          taskpane_bundle_hash?: string | null;
      };
      /**
       * @description One acceptable alternative to a position's standard language.
       *     Ranked 1-based (1 = preferred fallback). Stored as JSONB on
       *     ``playbook_positions.fallback_tiers`` (M3-A1).
       */
      FallbackTier: {
          rank: number;
          description: string;
          language: string;
      };
      /**
       * @description One issue in a playbook — the org's standard + fallbacks for a
       *     clause. Mirrors the ``Position`` shape in PRD §3.7.
       */
      Position: {
          /** Format: uuid */
          id: string;
          issue: string;
          description?: string;
          standard_language: string;
          fallback_tiers?: components["schemas"]["FallbackTier"][];
          redline_strategy?: string;
          /** @enum {string} */
          severity_if_missing: "critical" | "high" | "medium" | "low";
          detection_keywords?: string[];
          detection_examples?: string[];
          position_order?: number;
      };
      /**
       * @description Full playbook — header plus ordered positions. Mirrors PRD §3.7.
       *     ``GET /api/v1/playbooks`` returns this shape with ``positions``
       *     empty; ``GET /api/v1/playbooks/{id}`` returns it with the full
       *     position list inlined.
       */
      Playbook: {
          /** Format: uuid */
          id: string;
          name: string;
          contract_type: string;
          description?: string;
          version?: string;
          /** Format: uuid */
          created_by?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
          positions?: components["schemas"]["Position"][];
      };
      /**
       * @description Request shape for a single position when creating or updating a
       *     playbook (M3-A6). Identical to ``Position`` minus the server-
       *     assigned ``id`` (the server mints UUIDs at insert time).
       */
      PositionCreate: {
          issue: string;
          description?: string;
          standard_language: string;
          fallback_tiers?: components["schemas"]["FallbackTier"][];
          redline_strategy?: string;
          /** @enum {string} */
          severity_if_missing: "critical" | "high" | "medium" | "low";
          detection_keywords?: string[];
          detection_examples?: string[];
          position_order?: number;
      };
      /**
       * @description Request shape for ``POST /api/v1/playbooks`` (M3-A6). The server
       *     sets ``created_by`` to the caller's id unconditionally; there is
       *     no path to mint a built-in (``created_by IS NULL``) via the HTTP
       *     surface (built-ins ship via seed migration only).
       */
      PlaybookCreate: {
          name: string;
          contract_type: string;
          description?: string;
          version?: string;
          positions?: components["schemas"]["PositionCreate"][];
      };
      /**
       * @description Request shape for ``PATCH /api/v1/playbooks/{id}`` (M3-A6). All
       *     fields optional; a missing field is "leave alone." If
       *     ``positions`` is supplied, the server **atomically replaces**
       *     the entire positions list. To leave positions alone, omit the
       *     field; to clear them, send ``positions: []``.
       */
      PlaybookUpdate: {
          name?: string;
          contract_type?: string;
          description?: string;
          version?: string;
          positions?: components["schemas"]["PositionCreate"][] | null;
      };
      /**
       * @description Request shape for ``POST /api/v1/playbooks/easy`` (M3-A6). The
       *     document corpus the wizard's Step 1 collected, plus the
       *     contract family and an optional caller-supplied name.
       */
      EasyPlaybookGenerationCreate: {
          document_ids: string[];
          /**
           * @description The contract family the playbook targets ("NDA",
           *     "MSA-SaaS", "DPA", etc.). Free-form; passed to the
           *     extractor + assembly LLM calls as a hint.
           */
          contract_type: string;
          /**
           * @description Playbook name. Falls back to "Generated {contract_type}
           *     Playbook" if omitted.
           */
          name?: string | null;
          /**
           * @description Reserved for a future ephemeral-upload mode. Currently
           *     always true; uploaded documents persist to the user's
           *     library per M3-A6 §3.3.
           * @default true
           */
          persist_documents_after_generation: boolean;
      };
      /**
       * @description One row from the ``easy_playbook_generations`` table. Returned
       *     by ``POST /api/v1/playbooks/easy`` (at status ``pending``) and
       *     by ``GET /api/v1/playbooks/easy/{id}`` (the wizard's poll
       *     target). ``draft_playbook`` is populated only on
       *     ``status='completed'`` and carries the assembled
       *     ``PlaybookCreate`` shape for the Step 3 inline editor.
       */
      EasyPlaybookGeneration: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id?: string | null;
          contract_type: string;
          /** @enum {string} */
          status: "pending" | "running" | "completed" | "error";
          document_ids: string[];
          /**
           * @description The assembled ``PlaybookCreate`` shape. ``null`` until the
           *     worker reaches ``status='completed'``.
           */
          draft_playbook?: {
              [key: string]: unknown;
          } | null;
          error_message?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          started_at?: string | null;
          /** Format: date-time */
          completed_at?: string | null;
      };
      /**
       * @description One execution of a playbook against a target document.
       *     Status lifecycle: ``pending → running → completed | error``.
       *     ``results`` is populated on ``completed``; ``error`` is populated
       *     on ``error``. ``completed_at`` is non-null in either terminal state.
       */
      PlaybookExecution: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          playbook_id: string;
          /** Format: uuid */
          target_document_id: string;
          /** Format: uuid */
          user_id?: string | null;
          /** Format: uuid */
          project_id?: string | null;
          /** @enum {string} */
          status: "pending" | "running" | "completed" | "error";
          /**
           * @description Per-position outcomes + summary. Shape is versioned via
           *     ``schema_version`` (currently ``m3-a2-v1``); see the
           *     M3-A2 executor module for the canonical structure.
           */
          results?: {
              [key: string]: unknown;
          } | null;
          error?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          completed_at?: string | null;
      };
      /**
       * @description Request body for ``POST /api/v1/tabular/preview-cost``. Either
       *     ``skill_name`` or ``columns`` must be supplied (not both).
       */
      TabularPreviewCostRequest: {
          document_ids: string[];
          /** @description Name of a registered ``output_format: table`` skill. */
          skill_name?: string | null;
          /** @description Ad-hoc column spec (alternative to ``skill_name``). */
          columns?: components["schemas"]["ColumnSpec"][] | null;
      };
      TabularPreviewCostResponse: {
          /** @description ``len(document_ids) * len(columns)``. */
          cells_count: number;
          /** @description Per-cell token average x cells_count. */
          estimated_tokens: number;
          /**
           * @description Per-cell rolling-average cost x cells_count, serialized as
           *     a JSON string to preserve decimal precision.
           */
          estimated_cost_usd: string;
          /**
           * @description Map of tier label (``tier_1`` / ``tier_2`` / ... or
           *     ``default``) to cell count routed at that tier. Columns
           *     without an explicit ``minimum_inference_tier`` count in
           *     the ``default`` bucket.
           */
          per_tier_breakdown: {
              [key: string]: number;
          };
          /**
           * @description Number of cells that will run ensemble Citation-Engine
           *     verification (``len(document_ids) * ensemble-column count``).
           *     ``0`` when no column is ensemble-verified.
           */
          ensemble_cells_count?: number;
          /**
           * @description The ensemble judge-call cost included in
           *     ``estimated_cost_usd`` (= ``n_judges * per-judge-cost *
           *     ensemble_cells_count``), serialized as a JSON string to
           *     preserve decimal precision. ``"0"`` when no column is
           *     ensemble-verified. Note that ``estimated_cost_usd`` is the
           *     TOTAL (base extraction + this premium); ``estimated_tokens``
           *     is extraction-only and excludes judge tokens.
           */
          ensemble_premium_usd?: string;
      };
      /**
       * @description Request body for ``POST /api/v1/tabular/execute``. Either
       *     ``skill_name`` or ``columns`` must be supplied (not both).
       *     ``confirmed_cost_usd`` echoes the preview value so the row
       *     carries an audit trail of the operator confirming a specific
       *     cost ceiling.
       */
      TabularExecutionCreate: {
          document_ids: string[];
          skill_name?: string | null;
          columns?: components["schemas"]["ColumnSpec"][] | null;
          /**
           * @description Operator-confirmed cost from the preview endpoint. Persisted
           *     to ``tabular_executions.cost_estimate_usd``.
           */
          confirmed_cost_usd?: string | null;
      };
      /**
       * @description One row from the ``tabular_executions`` table. Lifecycle:
       *     ``pending → running → completed | failed | cancelled``.
       *     ``results`` is populated by the aggregate node on ``completed``;
       *     ``error_text`` is populated on ``failed``. Soft-deleted rows
       *     (``deleted_at`` non-null) are invisible to list / detail
       *     endpoints.
       */
      TabularExecution: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id?: string | null;
          /**
           * Format: uuid
           * @description Non-null on bulk-op sibling rows (Phase C prep doc Decision
           *     C-9). Bulk ops spawn siblings rather than mutating the
           *     original grid, preserving auditability.
           */
          parent_execution_id?: string | null;
          /**
           * @description Source skill name; ``null`` for ad-hoc executions where the
           *     operator typed columns directly in the wizard.
           */
          skill_name?: string | null;
          /** @enum {string} */
          status: "pending" | "running" | "completed" | "failed" | "cancelled";
          document_ids: string[];
          /**
           * @description Per-document display names (operator-uploaded filenames),
           *     parallel to ``document_ids`` in selection order. Assembled on
           *     the response by ``_to_response``; not a stored column.
           */
          document_names: string[];
          columns: components["schemas"]["ColumnSpec"][];
          /**
           * @description Assembled grid shape with rows + per-cell results. Shape is
           *     versioned via ``schema_version`` (currently ``m3-c2-v1``).
           *
           *     Each cell result also carries ``verification_method``
           *     (string, nullable) — the per-cell ensemble Citation-Engine
           *     verification outcome (``ensemble_strict`` /
           *     ``ensemble_majority``), or ``null`` when the cell's column is
           *     not ensemble-verified or verification did not confirm support.
           *
           *     Each cell carries a ``citations`` array. A tabular cell
           *     ``Citation`` is distinct from the chat ``Citation`` schema; it
           *     has: ``citation_id`` (uuid; deterministic display-only id —
           *     DE-309), ``document_id`` (uuid; the source ``documents.id``),
           *     ``chunk_id`` (uuid, nullable; the cited ``document_chunks.id``),
           *     and ``confidence`` (one of ``high|medium|low|failed``). Each
           *     citation additionally carries ``verification_method`` (string,
           *     nullable) — the Citation-Engine verification method
           *     (``ensemble_strict`` / ``ensemble_majority``), or ``null`` when
           *     the cell's column is not ensemble-verified or verification did
           *     not confirm support. It is mirrored from the cell-level value.
           *
           *     On ``GET /api/v1/tabular/executions/{id}`` (only) each citation
           *     is additionally enriched at read time so the frontend can open
           *     the cited source in its doc panel (same UX as chat citations):
           *
           *     - ``source_file_id`` (uuid, nullable): the source document's
           *       ``documents.file_id`` — the ``files.id`` the doc panel keys
           *       off. ``null`` when the backing chunk row is missing/stale.
           *     - ``source_page`` (integer, nullable): the cited chunk's
           *       ``document_chunks.page_start`` (nullable — best-effort page
           *       assignment).
           *     - ``source_text`` (string, nullable): the cited chunk's full
           *       ``document_chunks.content`` (the frontend locates/highlights
           *       the cited span within it).
           *
           *     These three fields are resolved via two batched ``IN`` queries
           *     (chunks, then documents) — no N+1 — and are ``null`` on the
           *     list/export paths, which do not enrich.
           */
          results?: {
              [key: string]: unknown;
          } | null;
          cost_estimate_usd?: string | null;
          cost_actual_usd?: string | null;
          error_text?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          started_at?: string | null;
          /** Format: date-time */
          completed_at?: string | null;
      };
      /**
       * @description Compact projection used by the list endpoint. Drops the
       *     (potentially large) ``results`` payload — operators fetch the
       *     full execution row when they open one.
       */
      TabularExecutionSummary: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id?: string | null;
          /** Format: uuid */
          parent_execution_id?: string | null;
          skill_name?: string | null;
          /** @enum {string} */
          status: "pending" | "running" | "completed" | "failed" | "cancelled";
          document_count: number;
          column_count: number;
          cost_estimate_usd?: string | null;
          cost_actual_usd?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          completed_at?: string | null;
      };
      AdminUserRow: {
          /** Format: uuid */
          id: string;
          /** Format: email */
          email: string;
          display_name?: string | null;
          /** @enum {string} */
          role: "admin" | "member" | "viewer";
          is_admin: boolean;
          mfa_enabled: boolean;
          must_change_password: boolean;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          last_login_at?: string | null;
          /** Format: date-time */
          deletion_scheduled_at?: string | null;
      };
      /**
       * @description Read-only view of an ``autonomous_findings`` row — one analysis
       *     finding emitted by a run via the ``emit_finding`` chokepoint.
       *     ``content`` is the finding body (the LLM's ``summary``).
       *     ``severity`` is LLM-emitted free text (no CHECK; ``info`` |
       *     ``warn`` | ``critical`` are the intended values).
       */
      AutonomousFindingRead: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          session_id: string;
          severity: string;
          title: string;
          content: string;
          /** Format: date-time */
          created_at: string;
      };
      /**
       * @description Paginated list of a session's findings, in stable
       *     ``created_at ASC, id ASC`` order — one run's rows typically
       *     share ``created_at`` (transaction-stable ``now()``); ``id`` is
       *     the pagination tiebreaker. Repeatable, not a guaranteed
       *     emission sequence.
       */
      AutonomousFindingListResponse: {
          findings: components["schemas"]["AutonomousFindingRead"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      /**
       * @description Read-only view of an ``autonomous_artifacts`` row — a reference to
       *     one document-grade artifact (a markdown memo) an opted-in run
       *     persisted into its target knowledge base via the ``emit_artifact``
       *     chokepoint. ``name`` and ``mime`` are LLM-emitted free text (no
       *     CHECK; the ``severity`` precedent).
       */
      AutonomousArtifactRead: {
          /** Format: uuid */
          id: string;
          name: string;
          mime: string;
          size_bytes: number;
          /**
           * Format: uuid
           * @description The backing ``files`` row. The FK is ``ON DELETE SET NULL`` —
           *     null means the file was later hard-deleted; the name/size
           *     metadata here survives. The KB document itself outlives the
           *     session (deleting the session removes only this reference).
           */
          file_id?: string | null;
          /**
           * Format: uuid
           * @description NOT a column on ``autonomous_artifacts`` — enriched at read
           *     time via the unique ``documents.file_id`` (1:1) so a client
           *     can deep-link the KB document. Null when ``file_id`` is null
           *     or no ``documents`` row exists for the file.
           */
          document_id?: string | null;
          /** Format: date-time */
          created_at: string;
      };
      /**
       * @description Paginated list of a session's artifact references, in the same
       *     stable ``created_at ASC, id ASC`` order as the findings list —
       *     repeatable, not a guaranteed emission sequence.
       */
      AutonomousArtifactListResponse: {
          artifacts: components["schemas"]["AutonomousArtifactRead"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      /**
       * @description Read-only view of an ``autonomous_memory`` row.  Returned by the
       *     list, keep, dismiss, and delete endpoints.
       */
      AutonomousMemoryRead: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id: string;
          /** @enum {string} */
          state: "proposed" | "kept" | "dismissed";
          category: string;
          content: string;
          /** Format: uuid */
          source_session_id?: string | null;
          /** Format: date-time */
          kept_at?: string | null;
          /** Format: date-time */
          deleted_at?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      /** @description Paginated list of autonomous memory entries (non-deleted, newest first). */
      AutonomousMemoryListResponse: {
          entries: components["schemas"]["AutonomousMemoryRead"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      /**
       * @description Optional request body for ``POST /autonomous/memory/{id}/keep``.
       *     If ``content`` is provided, the memory entry's text is overwritten
       *     on keep (edit-on-keep).
       */
      MemoryKeepRequest: {
          content?: string | null;
      };
      /**
       * @description Read-only view of a ``precedent_entries`` row.  Returned by the
       *     list, dismiss endpoints.
       */
      PrecedentEntryRead: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id: string;
          pattern_kind: string;
          summary: string;
          observed_count: number;
          /** Format: uuid */
          source_session_id?: string | null;
          /** Format: date-time */
          dismissed_at?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      /** @description Paginated list of precedent entries (non-dismissed, newest first). */
      PrecedentEntryListResponse: {
          entries: components["schemas"]["PrecedentEntryRead"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      /**
       * @description Request body for ``POST /autonomous/precedents/{id}/promote``.
       *     ``project_id`` is the target Project; the caller must own it.
       */
      PromotePrecedentRequest: {
          /** Format: uuid */
          project_id: string;
      };
      /**
       * @description Read-only view of a ``project_context_proposals`` row — a proposal
       *     to promote a precedent into a Project's context document.  Only the
       *     user accepting a proposal writes ``projects.context_md`` (ADR 0013 D5).
       */
      ProjectContextProposalRead: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id: string;
          /** Format: uuid */
          precedent_id: string;
          /** Format: uuid */
          project_id: string;
          suggested_md: string;
          /** @enum {string} */
          state: "proposed" | "accepted" | "rejected";
          /** Format: date-time */
          accepted_at?: string | null;
          /** Format: date-time */
          rejected_at?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      /** @description Paginated list of project-context proposals (newest first). */
      ProjectContextProposalListResponse: {
          proposals: components["schemas"]["ProjectContextProposalRead"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      /**
       * @description Read-only view of an ``autonomous_schedules`` row — a cron-triggered
       *     run definition.
       */
      AutonomousScheduleRead: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id: string;
          /** Format: uuid */
          project_id?: string | null;
          name?: string | null;
          cron_expr: string;
          /** Format: uuid */
          playbook_id?: string | null;
          skill_ref?: string | null;
          /** Format: uuid */
          target_kb_id?: string | null;
          enabled: boolean;
          /**
           * @description Opt-in document-grade artifact emission (Donna #8) for the
           *     schedule's sessions; default off so existing automations are
           *     unchanged.
           */
          emit_artifacts: boolean;
          max_cost_usd?: string | null;
          /** Format: date-time */
          last_run_at?: string | null;
          /** Format: date-time */
          next_run_at?: string | null;
          /** Format: date-time */
          deleted_at?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      /**
       * @description Request body for ``POST /autonomous/schedules``.  ``cron_expr`` is a
       *     five-field cron string (minute hour day-of-month month day-of-week)
       *     supporting ``*``, lists, ranges, and steps; invalid expressions
       *     return 422.
       */
      AutonomousScheduleCreate: {
          cron_expr: string;
          name?: string | null;
          /** Format: uuid */
          playbook_id?: string | null;
          skill_ref?: string | null;
          /** Format: uuid */
          target_kb_id?: string | null;
          /** Format: uuid */
          project_id?: string | null;
          /** @default true */
          enabled: boolean;
          /**
           * @description Opt-in document-grade artifact emission (Donna #8) for the
           *     schedule's sessions; default off so existing automations are
           *     unchanged.
           * @default false
           */
          emit_artifacts: boolean;
          max_cost_usd?: string | null;
      };
      /**
       * @description Request body for ``PATCH /autonomous/schedules/{id}``.  All fields
       *     optional.  Changing ``cron_expr`` re-validates (422) and recomputes
       *     ``next_run_at``.  The matter (``project_id``) may be reassigned; an
       *     explicit ``null`` unassigns it, and a non-null ``project_id`` the
       *     caller does not own returns 404 (id-probing-safe).
       */
      AutonomousScheduleUpdate: {
          name?: string | null;
          cron_expr?: string | null;
          enabled?: boolean | null;
          /**
           * @description Toggle opt-in document-grade artifact emission (Donna #8)
           *     for the schedule's future sessions; omitted/null = unchanged.
           */
          emit_artifacts?: boolean | null;
          /** Format: uuid */
          playbook_id?: string | null;
          skill_ref?: string | null;
          /** Format: uuid */
          target_kb_id?: string | null;
          /** Format: uuid */
          project_id?: string | null;
          max_cost_usd?: string | null;
      };
      /**
       * @description Request body for ``POST /autonomous/run-now``.  Spawns one
       *     ``trigger_kind='manual'`` session.  Exactly one of ``playbook_id``
       *     / ``skill_ref`` must be set (zero or both → 422).  ``target_kb_id``
       *     / ``project_id`` are optional scope.  ``max_cost_usd`` is the
       *     per-run cap (NULL → fall back to the config default).  A manual
       *     run has no schedule/watch row to inherit ``emit_artifacts`` from,
       *     so this body IS the opt-in source.
       */
      AutonomousManualRunRequest: {
          /** Format: uuid */
          playbook_id?: string | null;
          skill_ref?: string | null;
          /** Format: uuid */
          target_kb_id?: string | null;
          /** Format: uuid */
          project_id?: string | null;
          max_cost_usd?: string | null;
          /**
           * @description Opt-in document-grade artifact emission (Donna #8) for this
           *     one-off run; default off so existing callers are unchanged.
           * @default false
           */
          emit_artifacts: boolean;
      };
      /** @description Paginated list of autonomous schedules (newest first). */
      AutonomousScheduleListResponse: {
          schedules: components["schemas"]["AutonomousScheduleRead"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      /**
       * @description Read-only view of an ``autonomous_watches`` row — a KB-arrival-
       *     triggered run definition. When a file is attached to
       *     ``knowledge_base_id``, an autonomous session spawns.
       */
      AutonomousWatchRead: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id: string;
          /** Format: uuid */
          project_id?: string | null;
          /** Format: uuid */
          knowledge_base_id: string;
          /** Format: uuid */
          playbook_id?: string | null;
          skill_ref?: string | null;
          enabled: boolean;
          /**
           * @description Opt-in document-grade artifact emission (Donna #8) for the
           *     watch's sessions; default off so existing automations are
           *     unchanged.
           */
          emit_artifacts: boolean;
          max_cost_usd?: string | null;
          /** Format: date-time */
          deleted_at?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      /**
       * @description Request body for ``POST /autonomous/watches``.  ``knowledge_base_id``
       *     is required and must be owned by the caller (404 otherwise; KB-sharing
       *     is out of scope).  The target (``playbook_id`` / ``skill_ref``) and
       *     ``project_id`` are optional; ``enabled`` defaults to true.
       */
      AutonomousWatchCreate: {
          /** Format: uuid */
          knowledge_base_id: string;
          /** Format: uuid */
          playbook_id?: string | null;
          skill_ref?: string | null;
          /** Format: uuid */
          project_id?: string | null;
          /** @default true */
          enabled: boolean;
          /**
           * @description Opt-in document-grade artifact emission (Donna #8) for the
           *     watch's sessions; default off so existing automations are
           *     unchanged.
           * @default false
           */
          emit_artifacts: boolean;
          max_cost_usd?: string | null;
      };
      /**
       * @description Request body for ``PATCH /autonomous/watches/{id}``.  All fields
       *     optional.  The watch's ``knowledge_base_id`` is immutable (not
       *     present here) — a watch is bound to its KB.  The matter
       *     (``project_id``) may be reassigned; an explicit ``null`` unassigns
       *     it, and a non-null ``project_id`` the caller does not own returns
       *     404 (id-probing-safe).
       */
      AutonomousWatchUpdate: {
          enabled?: boolean | null;
          /**
           * @description Toggle opt-in document-grade artifact emission (Donna #8)
           *     for the watch's future sessions; omitted/null = unchanged.
           */
          emit_artifacts?: boolean | null;
          /** Format: uuid */
          playbook_id?: string | null;
          skill_ref?: string | null;
          /** Format: uuid */
          project_id?: string | null;
          max_cost_usd?: string | null;
      };
      /** @description Paginated list of autonomous watches (newest first). */
      AutonomousWatchListResponse: {
          watches: components["schemas"]["AutonomousWatchRead"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      /**
       * @description Read-only view of an ``autonomous_notifications`` row. Written by
       *     the ``notify`` chokepoint handler. ``read_at`` IS NULL = unread;
       *     marking read is the dismiss action. ``channel`` is one of
       *     ``in_app`` / ``email`` / ``webhook`` (``webhook`` reserved).
       *     ``body``/``payload`` carry counts/IDs + a receipt link — never raw
       *     entity values. A run-completion notification's ``payload`` carries
       *     ``finding_count`` and ``artifact_count`` (``artifact_count`` is 0
       *     unless the run opted in via ``emit_artifacts``).
       */
      AutonomousNotificationRead: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id: string;
          /** Format: uuid */
          session_id: string;
          /** @enum {string} */
          channel: "in_app" | "email" | "webhook";
          title: string;
          body: string;
          payload?: {
              [key: string]: unknown;
          } | null;
          /** Format: date-time */
          read_at?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      /** @description Paginated list of autonomous notifications (newest first). */
      AutonomousNotificationListResponse: {
          notifications: components["schemas"]["AutonomousNotificationRead"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      /**
       * @description Read-only view of an ``autonomous_sessions`` row.  Returned by the
       *     halt, list, and detail endpoints.
       */
      AutonomousSessionRead: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id: string;
          /** Format: uuid */
          project_id?: string | null;
          /** @enum {string} */
          trigger_kind: "watch" | "schedule" | "suggestion" | "manual";
          /** Format: uuid */
          trigger_ref?: string | null;
          /** @enum {string} */
          current_phase: "intake" | "analysis" | "drafting" | "ethics_review" | "delivery";
          /** @enum {string} */
          halt_state: "running" | "halt_requested" | "halted" | "paused";
          max_cost_usd?: string | null;
          cost_total_usd: string;
          cost_cap_reached: boolean;
          idle_halt_minutes: number;
          /** Format: date-time */
          last_activity_at: string;
          /** @enum {string} */
          status: "running" | "completed" | "halted" | "failed";
          params?: {
              [key: string]: unknown;
          };
          result?: {
              [key: string]: unknown;
          } | null;
          error?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
          /** Format: date-time */
          completed_at?: string | null;
      };
      /** @description Paginated list of autonomous sessions (newest first). */
      AutonomousSessionListResponse: {
          sessions: components["schemas"]["AutonomousSessionRead"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      /**
       * @description Session detail view with live-reconstructed receipt.
       *     The receipt is built from audit rows on every request and contains
       *     phase transitions, tool calls, terminal reason, and session metadata.
       *     No raw document text or entity values are included.
       */
      AutonomousSessionDetailResponse: {
          session: components["schemas"]["AutonomousSessionRead"];
          /**
           * @description Audit-derived receipt: session_id, trigger_kind, status,
           *     halt_state, current_phase, cost_total_usd, max_cost_usd,
           *     cost_cap_reached, created_at, completed_at,
           *     phase_transitions (list), tool_calls (list),
           *     terminal_reason (string | null).
           */
          receipt: {
              [key: string]: unknown;
          };
      };
      AdminUserListResponse: {
          users: components["schemas"]["AdminUserRow"][];
          total_count: number;
          limit: number;
          offset: number;
      };
      LoginRequest: {
          /** Format: email */
          email: string;
          /** Format: password */
          password: string;
      };
      LoginResponse: {
          access_token: string;
          /** @enum {string} */
          token_type: "Bearer";
          /** @description Lifetime in seconds */
          expires_in: number;
          refresh_token?: string;
          user: components["schemas"]["User"];
      };
      TokenResponse: {
          /** @description Short-lived JWT access token (~15 min). */
          access_token: string;
          /**
           * @description Refresh token returned on /auth/login and rotated on every
           *     /auth/refresh per PRD §5.1. The bearer of the most recent
           *     refresh_token can mint new access tokens; older refresh
           *     tokens are revoked when rotation happens.
           */
          refresh_token: string;
          /** @enum {string} */
          token_type: "Bearer";
          /** @description Seconds until the access token expires. */
          expires_in: number;
      };
      MfaChallenge: {
          mfa_token: string;
          methods: ("totp" | "recovery_code")[];
      };
      ChangePasswordRequest: {
          /**
           * Format: password
           * @description The user's current password. Required even when the
           *     `must_change_password` flag is set — a stolen access token
           *     alone must not be sufficient to rotate credentials.
           */
          current_password: string;
          /**
           * Format: password
           * @description The replacement password. Must satisfy the deployment's
           *     password policy (minimum length, etc.) and must differ from
           *     `current_password`. The first-run admin flow accepts any
           *     password meeting policy; subsequent rotations may add
           *     complexity rules.
           */
          new_password: string;
      };
      User: {
          /** Format: uuid */
          id: string;
          /** Format: email */
          email: string;
          display_name?: string | null;
          is_admin: boolean;
          /**
           * @description Wave C — PRD §5.2 RBAC three-role system. ``admin`` has
           *     full access; ``member`` can mutate owned resources; ``viewer``
           *     is read-only. Mutating endpoints reject ``viewer`` via the
           *     ``MutatingUser`` dependency. Kept in sync with ``is_admin``
           *     (``role='admin'`` iff ``is_admin=true``).
           * @default member
           * @enum {string}
           */
          role: "admin" | "member" | "viewer";
          mfa_enabled: boolean;
          /**
           * @description When true, the user must call POST /api/v1/auth/change-password
           *     before they can use any other authenticated endpoint. Set on
           *     the auto-created first-run admin (Task B2) and on accounts
           *     after `reset-admin-password`. Other authenticated endpoints
           *     return 403 with `error.code = "password_change_required"`
           *     until this clears.
           */
          must_change_password: boolean;
          /**
           * @description Wave A — PRD §3.2 Enhance Prompt reasoning visibility:
           *     ``always_show`` (reasoning visible by default),
           *     ``disclosure`` (collapsed behind a toggle; spec default),
           *     ``on_request`` (hidden until the user opens the skill
           *     inspector). Modifiable via ``PATCH /users/me/preferences``.
           * @default disclosure
           * @enum {string}
           */
          reasoning_visibility: "always_show" | "disclosure" | "on_request";
          /**
           * @description Wave B v2 — PRD §3.2.1 / frontend spec §4.3. Where Enhance
           *     Prompt, Skill Creator, KB, and Apply Skill surface:
           *     ``prominent`` (dashboard cards; default) vs. ``inline``
           *     (toolbar only for veterans).
           * @default prominent
           * @enum {string}
           */
          featured_tools: "prominent" | "inline";
          /**
           * @description Wave B v2 — PRD §3.2.1 / frontend spec §4.3. Matter workspace
           *     pane composition (Wave C surfaces): ``three_pane`` (default),
           *     ``two_pane``, or ``one_pane``.
           * @default three_pane
           * @enum {string}
           */
          workspace_layout: "three_pane" | "two_pane" | "one_pane";
          /**
           * @description Wave B v2 — PRD §3.2.1 / frontend spec §4.3. Ambient trust
           *     pill format: ``labels`` (full text, e.g. "● self-hosted";
           *     default) vs. ``dots`` (minimal dot only).
           * @default labels
           * @enum {string}
           */
          trust_pills: "labels" | "dots";
          /**
           * @description Wave B v2 — PRD §3.2.1 / frontend spec §4.3. Per-message
           *     skill/tier/provider pill row visibility: ``always`` (visible
           *     by default) vs. ``collapsed`` (hidden until expanded).
           * @default always
           * @enum {string}
           */
          provenance_pills: "always" | "collapsed";
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          last_login_at?: string | null;
          /**
           * Format: date-time
           * @description Non-null while a GDPR Article 17 grace-period deletion is pending (set by POST /users/me/delete, cleared by .../delete/cancel).
           */
          deletion_scheduled_at?: string | null;
      };
      /**
       * @description All 6 personalization preference fields. Wave A (``reasoning_visibility``)
       *     per PRD §3.2; Wave B v2 fields per PRD §3.2.1 and frontend spec §4.3;
       *     ``autonomous_enabled`` per PRD §5 / M4-C2.
       */
      UserPreferences: {
          /**
           * @default disclosure
           * @enum {string}
           */
          reasoning_visibility: "always_show" | "disclosure" | "on_request";
          /**
           * @default prominent
           * @enum {string}
           */
          featured_tools: "prominent" | "inline";
          /**
           * @default three_pane
           * @enum {string}
           */
          workspace_layout: "three_pane" | "two_pane" | "one_pane";
          /**
           * @default labels
           * @enum {string}
           */
          trust_pills: "labels" | "dots";
          /**
           * @default always
           * @enum {string}
           */
          provenance_pills: "always" | "collapsed";
          autonomous_enabled: boolean;
      };
      /**
       * @description All fields optional; only supplied keys are updated. Wave B v2 adds
       *     four personalization fields per PRD §3.2.1 and frontend spec §4.3;
       *     ``autonomous_enabled`` per PRD §5 / M4-C2.
       */
      UserPreferencesUpdate: {
          /** @enum {string} */
          reasoning_visibility?: "always_show" | "disclosure" | "on_request";
          /** @enum {string} */
          featured_tools?: "prominent" | "inline";
          /** @enum {string} */
          workspace_layout?: "three_pane" | "two_pane" | "one_pane";
          /** @enum {string} */
          trust_pills?: "labels" | "dots";
          /** @enum {string} */
          provenance_pills?: "always" | "collapsed";
          autonomous_enabled?: boolean;
      };
      /**
       * @description PATCH body for `/api/v1/users/me`. Caller-scoped self-edit of the
       *     user's own profile. Currently `display_name` only: when supplied
       *     it is trimmed and must be non-empty after trimming. At least one
       *     updatable field must be present (an all-omitted body is a 422).
       *
       *     Email self-service editing is intentionally out of scope here —
       *     changing the login email pulls in re-verification, MFA, and
       *     uniqueness concerns and is deferred to a dedicated flow.
       */
      UserProfileUpdate: {
          /**
           * @description New display name. Trimmed server-side; must be non-empty after
           *     trimming. Omit to leave unchanged (but at least one field must
           *     be present, so an empty body is rejected).
           */
          display_name?: string;
      };
      Project: {
          /** Format: uuid */
          id: string;
          name: string;
          /**
           * @description URL-friendly identifier; unique-per-owner within the active set
           *     (an archived project's slug can be reused). Generated from
           *     `name` on create when not supplied; collisions resolve with a
           *     numeric suffix (`-2`, `-3`, ...).
           */
          slug: string;
          description?: string | null;
          /**
           * @description Free-form Markdown context document for the matter. Capped at
           *     100 KiB (UTF-8 bytes); exceeding the cap returns 422.
           */
          context_md?: string | null;
          /** Format: uuid */
          owner_id: string;
          /**
           * @description When true, every chat in this project is marked privileged in the audit log
           *     and the routed inference tier is forced to be at least minimum_inference_tier.
           *     Setting `privileged=true` requires `minimum_inference_tier` to be set;
           *     attempts to set one without the other return 422 (POST) or 400 (PATCH).
           */
          privileged: boolean;
          /**
           * @description When set, requests below this tier are refused
           * @enum {integer|null}
           */
          minimum_inference_tier?: 1 | 2 | 3 | 4 | 5 | null;
          /** @description Skills attached to this project, ordered by attachment time */
          attached_skill_names?: string[];
          /** @description Files attached to this project, ordered by attachment time */
          attached_file_ids?: string[];
          /**
           * @description System-managed flag added by migration 0022. When true, this
           *     project is the per-user try-it sandbox (slug ``__sandbox__``).
           *     Sandbox projects are excluded from the default ``GET /projects``
           *     list; pass ``include_sandbox=true`` or ``only_sandbox=true`` to
           *     surface them. Created by ``POST /projects/sandbox/ensure``.
           * @default false
           */
          is_sandbox: boolean;
          /**
           * Format: date-time
           * @description When set, the project is soft-deleted (archived); excluded from default list
           */
          archived_at?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      ProjectCreate: {
          name: string;
          /** @description Optional; defaults to slugified `name` with collision suffixes. */
          slug?: string;
          description?: string;
          /** @description Free-form Markdown context document; max 100 KiB. */
          context_md?: string;
          /** @default false */
          privileged: boolean;
          /** @enum {integer} */
          minimum_inference_tier?: 1 | 2 | 3 | 4 | 5;
      };
      ProjectUpdate: {
          name?: string;
          slug?: string;
          description?: string;
          /** @description Free-form Markdown context document; max 100 KiB. */
          context_md?: string;
          privileged?: boolean;
          /** @enum {integer|null} */
          minimum_inference_tier?: 1 | 2 | 3 | 4 | 5 | null;
          /**
           * @description When true, archive (soft-delete) the project; when false,
           *     unarchive a previously-archived project. The dedicated
           *     `DELETE /api/v1/projects/{id}` endpoint is the destructive
           *     equivalent of `PATCH {archived: true}`.
           */
          archived?: boolean;
      };
      Chat: {
          /** Format: uuid */
          id: string;
          /**
           * @description Chat title. Defaults to "New chat"; auto-renamed to the
           *     first 80 chars of the first user message on first POST
           *     /messages. Never overwrites a user-set title (one-shot).
           */
          title: string;
          /** Format: uuid */
          owner_id: string;
          /** Format: uuid */
          project_id?: string | null;
          /**
           * Format: date-time
           * @description Soft-delete timestamp. NULL means active.
           */
          archived_at?: string | null;
          /** @description Count of persisted messages in this chat. */
          message_count?: number;
          /**
           * @description Opt-in per-chat "sticky skills" set (issue #207 finding 4).
           *     Empty means the sticky toggle is off (a new chat never inherits
           *     stickiness). When non-empty, these skill slugs are auto-applied
           *     (unioned) to every turn in this chat until cleared. Set via
           *     `MessageCreate.set_sticky`.
           */
          sticky_skills?: string[];
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      ChatCreate: {
          /**
           * @description Defaults to "New chat" when omitted. The chat will be
           *     auto-renamed from the first user message; supplying a
           *     non-default title here suppresses auto-rename.
           */
          title?: string;
          /** Format: uuid */
          project_id?: string | null;
      };
      /** @description PATCH body for /api/v1/chats/{chat_id}; partial update. */
      ChatUpdate: {
          title?: string;
          /** @description Set true to archive (soft-delete); false to unarchive. */
          archived?: boolean;
      };
      Message: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          chat_id: string;
          /** @enum {string} */
          role: "user" | "assistant" | "system" | "tool";
          content: string;
          /**
           * @description C2 / ADR 0007: skills the gateway applied for this message
           *     exchange. Captured on user messages from the request body
           *     and on assistant messages from the gateway response.
           */
          applied_skills?: string[];
          /**
           * @description Tier the request was routed against (set by gateway). NULL on user messages.
           * @enum {integer|null}
           */
          routed_inference_tier?: 1 | 2 | 3 | 4 | 5 | null;
          /** @description Provider that handled the request (assistant only). */
          routed_provider?: string | null;
          /** @description Native provider model name (assistant only). */
          routed_model?: string | null;
          prompt_tokens?: number | null;
          completion_tokens?: number | null;
          /**
           * @description USD cost estimate. The DB stores integer USD micros
           *     (1e-6 USD); the wire field is the floating-point USD value.
           */
          cost_estimate?: number | null;
          /**
           * @description Populated when the assistant message failed mid-stream or
           *     the gateway raised. Carries the canonical Error code
           *     (e.g., `provider_unavailable`, `gateway_timeout`).
           */
          error_code?: string | null;
          /** @description M2 populates this; M1 stores []. */
          citations?: components["schemas"]["Citation"][];
          /** Format: date-time */
          created_at: string;
      };
      MessageCreate: {
          content: string;
          /**
           * @description Model alias (e.g., 'smart', 'fast') or provider-native model name
           * @default smart
           */
          model: string;
          /**
           * @description When true, response is `text/event-stream` per OpenAI streaming
           *     convention. When false, response is a single JSON body with the
           *     assistant message and routing metadata (B5 default).
           * @default false
           */
          stream: boolean;
          /**
           * @description C2: skill names to attach. The backend forwards these as
           *     `lq_ai_skills` to the gateway, which fetches each from the
           *     backend's internal-skills endpoint and assembles the prompt.
           */
          skills?: string[];
          /**
           * @description Issue #207 finding 4 — opt-in per-chat "sticky skills" toggle.
           *     `true` snapshots this turn's applied skills as the chat's sticky
           *     set (auto-applied to later turns without re-sending); `false`
           *     clears it; omitted/null leaves it unchanged. Off by default — a
           *     new chat never inherits stickiness (fail-restrictive).
           * @default null
           */
          set_sticky: boolean | null;
          /**
           * @description C2: per-skill input bindings, keyed by skill name. Inner
           *     dict maps input variable names to values. Required inputs
           *     that the skill's frontmatter declares but the bindings
           *     don't provide cause a 400 with `code=skill_input_missing`.
           *
           *     Values are plain scalars interpolated into the skill body via
           *     `{{name}}` substitution (ADR 0006). There is NO `type:"file"`
           *     binding: passing a file UUID here interpolates the literal
           *     UUID string, not the file's document text. For per-turn
           *     document context use the separate `file_ids` channel below —
           *     `skill_inputs` and `file_ids` are distinct; a `file_id` is
           *     NOT bindable to a skill file-input via `skill_inputs`.
           */
          skill_inputs?: {
              [key: string]: {
                  [key: string]: unknown;
              };
          };
          /**
           * @description Donna: caller-owned file UUIDs supplying ephemeral,
           *     per-message document context for this one chat turn.
           *     Distinct from KB attach (project-scoped, persistent) and
           *     from `skill_inputs` (scalar skill params — see the note
           *     above; no `type:"file"` binding is wired). Each id is
           *     validated server-side to exist and be owned by the caller;
           *     a foreign, unknown, or soft-deleted id returns 404
           *     (id-probing-safe — indistinguishable from "not found").
           *     Validated ids are forwarded to the gateway as `lq_ai_file_ids`
           *     alongside `lq_ai_skills` and echoed back as `applied_file_ids`
           *     on the response / SSE `complete` frame. Capped at 16 entries.
           *     Omitted / empty is back-compatible.
           */
          file_ids?: string[];
      };
      /**
       * @description Non-streaming response for `POST /api/v1/chats/{chat_id}/messages`.
       *     The `routed_inference_tier`, `routed_provider`, and `cost_estimate`
       *     come from the gateway (B4). `applied_skills` lists the skills
       *     that were assembled into the prompt (C2). After C3 the backend
       *     also persists both the user and assistant message rows; the
       *     `message.id` carried here resolves to the persisted assistant
       *     row.
       */
      MessagePostResponse: {
          message: components["schemas"]["Message"];
          /** @description Empty until M2 (citation engine). */
          citations: components["schemas"]["Citation"][];
          /**
           * @description Routed Inference Tier as derived by the gateway (B4)
           * @enum {integer|null}
           */
          routed_inference_tier?: 1 | 2 | 3 | 4 | 5 | null;
          /** @description Provider name that handled the request (B4) */
          routed_provider?: string | null;
          /** @description USD cost estimate (gateway-side, when rate is configured) */
          cost_estimate?: number | null;
          /**
           * @description C2: skills that were successfully assembled into the prompt
           *     for this request. Empty when no skills were attached.
           */
          applied_skills?: string[];
          /**
           * @description Donna: caller-owned file ids that were validated and
           *     forwarded to the gateway as `lq_ai_file_ids` for this turn —
           *     the echo of `MessageCreate.file_ids` (mirrors
           *     `applied_skills`). Turn-scoped: there is no
           *     `messages.file_ids` column, so this surfaces only on the send
           *     response (and the SSE `complete` frame), not on rows read
           *     back via `GET /chats/{id}/messages`. Empty when none attached.
           */
          applied_file_ids?: string[];
      };
      /**
       * @description Frames emitted on the SSE stream. The first frame is a `start`
       *     event carrying the persisted assistant message id (so clients
       *     can poll the row later). Subsequent frames are `delta` events,
       *     each tagged with the `lq_ai_message_id`, the
       *     `routed_inference_tier`, and `applied_skills`. The final frame
       *     is either a `complete` event (success) or an `Error` envelope
       *     (the stream ended in failure; the assistant row is persisted
       *     with `error_code` populated for audit). Termination is
       *     signalled by the OpenAI-style `data: [DONE]` line.
       */
      MessageStreamEvent: components["schemas"]["MessageStart"] | components["schemas"]["MessageDelta"] | components["schemas"]["MessageComplete"] | components["schemas"]["Error"];
      /**
       * @description Opening frame on the SSE stream. Carries the assistant message
       *     id the backend generated *before* dispatch; the persisted row
       *     will eventually carry this same id, so the client can fetch the
       *     row later via `GET /chats/{id}/messages`.
       */
      MessageStart: {
          /** @enum {string} */
          type: "start";
          /** Format: uuid */
          lq_ai_message_id: string;
          /** Format: uuid */
          chat_id: string;
      };
      MessageDelta: {
          /** @enum {string} */
          type: "delta";
          delta: string;
          /**
           * Format: uuid
           * @description C3: the persisted assistant message id (stable across all frames).
           */
          lq_ai_message_id: string;
          /**
           * @description B4: routed tier surfaced on every chunk.
           * @enum {integer|null}
           */
          routed_inference_tier?: 1 | 2 | 3 | 4 | 5 | null;
          /** @description C2: skills assembled into the prompt. */
          applied_skills?: string[];
      };
      MessageComplete: {
          /** @enum {string} */
          type: "complete";
          /** Format: uuid */
          lq_ai_message_id: string;
          message: components["schemas"]["Message"];
          citations?: components["schemas"]["Citation"][];
          /**
           * @description C2: skills that were successfully assembled into the prompt
           *     for this request. Empty when no skills were attached.
           */
          applied_skills?: string[];
          /**
           * @description Donna: caller-owned file ids forwarded to the gateway as
           *     `lq_ai_file_ids` for this turn — the echo of
           *     `MessageCreate.file_ids` (mirrors `applied_skills`).
           *     Turn-scoped; not persisted. Empty when none attached.
           */
          applied_file_ids?: string[];
          /** @enum {integer|null} */
          routed_inference_tier?: 1 | 2 | 3 | 4 | 5 | null;
          routed_provider?: string | null;
      };
      Citation: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          source_file_id: string;
          source_offset_start?: number;
          source_offset_end?: number;
          source_page?: number | null;
          /** @description Verbatim text from source — verified to appear in source */
          source_text: string;
          /** @description Citation engine verified the quote */
          verified?: boolean;
          /**
           * @description True when the paraphrase judge (M2-C1) returned ``partial`` — the source supports the claim but only partially. Drives the M2-C2 UI's "verified with caveats" rendering (verified-paraphrase state).
           * @default false
           */
          partial: boolean;
      };
      SkillSummary: {
          name: string;
          /** @description Skill version. Free-form to accommodate skills authored before the formal authoring guide; the loader defaults to ``"unversioned"`` when the source frontmatter omits this field. */
          version: string;
          /** @enum {string} */
          scope: "builtin" | "user" | "team";
          title: string;
          description?: string;
          /** @description Attribution string from the skill's ``lq_ai.author`` frontmatter (DE-316). Surfaced verbatim; absent when the frontmatter omits it. Read by the gateway's ``skill.execute`` OTel span as ``skill.author``. */
          author?: string;
          tags?: string[];
          /** @description Free-form jurisdiction tag (e.g., ``us``, ``regime-aware``, ``agnostic``). Surfaced verbatim from the skill's frontmatter. */
          jurisdiction?: string;
          /** @description Inference-tier floor declared by the skill, if any. The gateway's tier-floor enforcement (Task D1) consults this; C1 only surfaces the value. */
          minimum_inference_tier?: number;
          /** @description Skill's documented output format (e.g., ``report``, ``markdown``, ``structured_checklist``, ``redline``). Free-form per the corpus. */
          output_format?: string;
      };
      /** @description One column in an ``output_format: table`` skill (M3-C1). The Tabular Review workflow (M3-C2) runs each ``(document, column)`` cell as a Citation-Engine-grounded extraction. */
      ColumnSpec: {
          /** @description Grid column header. */
          name: string;
          /** @description Per-row extraction prompt instantiated against each document. */
          query: string;
          /** @description Per-column override of the skill-level ``ensemble_verification`` field. ``true`` routes this column's cells through Stage 4 of the Citation Engine cascade. */
          ensemble_verification?: boolean | null;
          /** @description Per-column override of the skill-level tier floor. High-stakes columns can demand Tier 4+ while routine columns route Tier 1. */
          minimum_inference_tier?: number | null;
      };
      Skill: components["schemas"]["SkillSummary"] & {
          /**
           * Format: uuid
           * @description Wave D.2 — underlying ``user_skills.id`` row UUID when the resolved scope is ``user`` or ``team``. ``null`` for built-in (filesystem-canonical) skills, which have no DB row. The skill detail page's Versions tab needs this id to call the audit-history endpoint; surfacing it on the detail GET avoids a second round-trip to resolve slug → id.
           */
          id?: string | null;
          /** @description Frontmatter YAML */
          content_yaml: string;
          /** @description Body markdown */
          content_md: string;
          reference_files?: {
              path: string;
              content: string;
          }[];
          example_files?: {
              path: string;
              content: string;
          }[];
          /** @description M3-C1 — column definitions for ``output_format: table`` skills. ``null`` for non-table skills. The validator rejects ``output_format: table`` skills that lack a non-empty ``columns`` list at load time. */
          columns?: components["schemas"]["ColumnSpec"][] | null;
          /** @description Connector identifiers the skill declares it uses (C5). */
          tool_usage?: string[] | null;
          /** @description Declared connectors not configured in this deployment; null when undeterminable. Informational, never gating. */
          unavailable_tool_usage?: string[] | null;
      };
      SkillInputDef: {
          name: string;
          /** @description Free-form per corpus reality (text, enum, boolean, integer, structured, file, ...). */
          type?: string | null;
          /** @default false */
          required: boolean;
          description?: string | null;
          enum?: string[] | null;
          default?: unknown;
      };
      SkillInputs: {
          name: string;
          required: components["schemas"]["SkillInputDef"][];
          optional: components["schemas"]["SkillInputDef"][];
      };
      EnhancePromptAttachedSkill: {
          name: string;
          description?: string | null;
      };
      EnhancePromptAttachedFile: {
          /** Format: uuid */
          file_id?: string | null;
          filename: string;
          mime_type?: string | null;
          description?: string | null;
      };
      EnhancePromptRequest: {
          raw_input: string;
          /** Format: uuid */
          chat_id?: string | null;
          attached_skills?: components["schemas"]["EnhancePromptAttachedSkill"][];
          attached_files?: components["schemas"]["EnhancePromptAttachedFile"][];
          jurisdiction?: string | null;
          /** @description Optional model alias override. Defaults to ``fast``. */
          model?: string | null;
      };
      EnhancePromptResponse: {
          /** Format: uuid */
          interaction_id: string;
          expansion_applied: boolean;
          /**
           * @description The expansion when ``expansion_applied=true``, or the original
           *     ``raw_input`` (echoed back for client convenience) when
           *     ``expansion_applied=false``.
           */
          expanded_prompt: string;
          reasoning: string[];
          skip_reason?: string | null;
          /** @description Human-readable render of the expansion + reasoning the application can show in the review screen. */
          preview_to_user?: string;
          routed_inference_tier?: number | null;
          routed_provider?: string | null;
          routed_model?: string | null;
      };
      /** @description All fields optional; only supplied keys move. */
      EnhancePromptOutcomeUpdate: {
          used?: boolean | null;
          edited_before_use?: boolean | null;
      };
      CurrentTierResponse: {
          provider: string;
          model: string;
          routed_inference_tier?: number | null;
          routed_provider_type?: string | null;
          explanation?: string;
      };
      TierConfigResponse: {
          allowed_tiers_global: number[];
          default_minimum_tier: number;
          privileged_minimum_tier: number;
          warn_on_tiers: number[];
      };
      UsageRow: {
          group_key: string;
          request_count: number;
          tokens_in_sum: number;
          tokens_out_sum: number;
          cost_estimate_sum: number;
      };
      UsageResponse: {
          rows: components["schemas"]["UsageRow"][];
          /** @enum {string} */
          group_by: "user" | "provider" | "model" | "tier" | "day";
          total_request_count: number;
          total_tokens_in: number;
          total_tokens_out: number;
          total_cost_estimate: number;
      };
      ChatSearchHit: {
          /** Format: uuid */
          chat_id: string;
          title: string;
          snippet: string;
          /** @enum {string} */
          match_source: "title" | "message";
          rank: number;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      ChatSearchResponse: {
          items: components["schemas"]["ChatSearchHit"][];
          query: string;
      };
      File: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          owner_id: string;
          /** Format: uuid */
          project_id?: string | null;
          filename: string;
          mime_type: string;
          size_bytes: number;
          hash_sha256?: string;
          /**
           * @description Lifecycle: `pending` (just uploaded; C4 sets this on insert)
           *     → `processing` (C5 worker has picked it up) → `ready`
           *     (parsed, chunks persisted) OR `failed` (with `ingestion_error`
           *     set; e.g., `unsupported_type` for unsupported MIMEs (anything
           *     that is neither PDF nor text/Markdown), `decode_error` for a
           *     non-UTF-8 text upload, or `parse_failed` for corrupt PDFs).
           * @enum {string}
           */
          ingestion_status?: "pending" | "processing" | "ready" | "failed";
          /**
           * @description Set when `ingestion_status='failed'`. Values include
           *     `unsupported_type`, `unsupported_content`, `parse_failed`,
           *     and `decode_error` (a `text/plain` or `text/markdown` upload
           *     whose bytes are not valid UTF-8).
           */
          ingestion_error?: string | null;
          /**
           * @description Populated by the C5 document pipeline once
           *     `ingestion_status='ready'`; `null` while pending /
           *     processing / failed.
           */
          page_count?: number | null;
          /**
           * @description Populated by the C5 document pipeline once
           *     `ingestion_status='ready'`; counts characters of the
           *     canonical extracted text (PyMuPDF for PDF; the verbatim
           *     decoded bytes for text/Markdown), not the original byte
           *     stream.
           */
          character_count?: number | null;
          /**
           * Format: uuid
           * @description UUID of the parsed-content `documents` row (M3-A6 Phase 6).
           *     Distinct from `id` (the File UUID). `null` until the C5
           *     parse pipeline produces the row; the Easy Playbook wizard
           *     polls `GET /files/{id}` until this flips non-null, then
           *     passes the value to `POST /playbooks/easy` in `document_ids`.
           */
          document_id?: string | null;
          /** Format: date-time */
          created_at: string;
      };
      KnowledgeBase: {
          /** Format: uuid */
          id: string;
          name: string;
          description?: string | null;
          /** Format: uuid */
          owner_id: string;
          /** Format: uuid */
          project_id?: string | null;
          /**
           * @description Per-KB default for the hybrid score combine. 0 = vector-only;
           *     1 = FTS-only; 0.5 = balanced (per ADR 0008).
           */
          hybrid_alpha: number;
          file_count: number;
          chunk_count: number;
          /** Format: date-time */
          archived_at?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      KnowledgeBaseCreate: {
          name: string;
          description?: string | null;
          /** Format: uuid */
          project_id?: string | null;
          /** @default 0.5 */
          hybrid_alpha: number;
      };
      KnowledgeBaseUpdate: {
          name?: string;
          description?: string | null;
          /** Format: uuid */
          project_id?: string | null;
          hybrid_alpha?: number;
          /** @description true to archive; false to unarchive */
          archived?: boolean;
      };
      /**
       * @description One row of `GET /api/v1/knowledge-bases/{kb_id}/files`. Mirrors
       *     `File` (the wire shape returned by `POST /files` /
       *     `GET /files/{id}`) and adds `attached_at` from the join row so
       *     the Knowledge surface can sort by attach time.
       */
      KBFile: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          owner_id: string;
          /** Format: uuid */
          project_id?: string | null;
          filename: string;
          mime_type: string;
          size_bytes: number;
          hash_sha256: string;
          /** @enum {string} */
          ingestion_status: "pending" | "processing" | "ready" | "failed";
          ingestion_error?: string | null;
          page_count?: number | null;
          character_count?: number | null;
          /**
           * Format: uuid
           * @description The parsed-content `documents` row UUID, distinct from `id`
           *     (the File UUID). Null until the C5 parse pipeline produces
           *     a documents row. Added in M3-A4 so playbook-execute callers
           *     can resolve File → Document client-side without a second
           *     fetch.
           */
          document_id?: string | null;
          /** Format: date-time */
          created_at: string;
          /**
           * Format: date-time
           * @description When the file was attached to this KB (from
           *     `knowledge_base_files.attached_at`).
           */
          attached_at: string;
      };
      KBQueryRequest: {
          query: string;
          /** @default 10 */
          top_k: number;
          /**
           * @description Override the KB's stored alpha for this query. Omit to use
           *     the KB default.
           */
          hybrid_alpha?: number;
      };
      KBQueryResponse: {
          results: components["schemas"]["SearchResult"][];
          /** @description The alpha actually used (per-query override or KB default). */
          hybrid_alpha: number;
      };
      SearchResult: {
          chunk: {
              /** Format: uuid */
              id: string;
              /** Format: uuid */
              document_id: string;
              /** Format: uuid */
              file_id: string;
              file_name: string;
              content: string;
              page_start?: number | null;
              page_end?: number | null;
              char_offset_start: number;
              char_offset_end: number;
          };
          /** @description Combined hybrid score: (1 - alpha) * vector + alpha * fts. Min-max normalized; in [0, 1]. */
          score: number;
          score_components: {
              vector: number;
              fts: number;
          };
      };
      SavedPrompt: {
          /** Format: uuid */
          id: string;
          /** Format: uuid */
          user_id: string;
          name: string;
          prompt_text: string;
          tags?: string[];
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at?: string;
      };
      UserSkill: {
          /** Format: uuid */
          id: string;
          /**
           * @description 'user' is owned by ``owner_user_id``; 'team' is owned by ``owner_team_id`` (D8.1b).
           * @enum {string}
           */
          scope: "user" | "team";
          /**
           * Format: uuid
           * @description Set when scope='user'; null when scope='team'. Exactly one of owner_user_id / owner_team_id is non-null (enforced by ck_user_skills_scope_owner_consistency).
           */
          owner_user_id?: string | null;
          /**
           * Format: uuid
           * @description Set when scope='team' (D8.1b). null when scope='user'.
           */
          owner_team_id?: string | null;
          /** @description Stable identifier; matches filesystem skill folder-name conventions. */
          slug: string;
          display_name: string;
          description: string;
          /** @description User-set free-form semver (e.g. "1.0.0"). */
          version: string;
          tags?: string[];
          /** @description Arbitrary ``lq_ai:`` extension keys (jurisdiction, output_format, minimum_inference_tier, etc.). */
          frontmatter_extra?: {
              [key: string]: unknown;
          };
          body: string;
          /** @description Chat-composer trigger alias (e.g. ``/nda``). Added by migration 0023. */
          slash_alias?: string | null;
          /** @description Slug of the source skill when this row was forked. Added by migration 0023. */
          forked_from?: string | null;
          /**
           * Format: date-time
           * @description Soft-delete timestamp; null when active.
           */
          archived_at?: string | null;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
      };
      UserSkillCreate: {
          slug: string;
          display_name: string;
          description: string;
          body: string;
          /** @default 1.0.0 */
          version: string;
          tags?: string[];
          frontmatter_extra?: {
              [key: string]: unknown;
          };
          /**
           * @description Defaults to 'user'. 'team' (D8.1b) requires owner_team_id and gates on team-admin role.
           * @default user
           * @enum {string}
           */
          scope: "user" | "team";
          /**
           * Format: uuid
           * @description Required when scope='team'; must be null when scope='user'. 422 if the combination is inconsistent. 404 if the caller is not a team-admin of the named team (id-probing-safe).
           */
          owner_team_id?: string | null;
          /**
           * @description Optional chat-composer trigger alias (e.g. ``/nda``). Must be
           *     ``/`` followed by 1–32 lowercase alphanumeric-or-dash chars.
           *     Unique per owner within the active (non-archived) set; 422 on
           *     collision with ``"slash_alias '...' is already used by another
           *     of your skills."``.
           */
          slash_alias?: string | null;
          /**
           * @description Slug of the source skill when this row was created by forking a
           *     built-in or another skill via the detail-page fork button. Set
           *     on create; read-only afterward. Stored as plain text (no FK —
           *     the source may be a filesystem-canonical built-in with no DB row).
           */
          forked_from?: string | null;
      };
      /** @description All fields optional; only supplied keys are updated. */
      UserSkillUpdate: {
          display_name?: string;
          description?: string;
          body?: string;
          version?: string;
          tags?: string[];
          frontmatter_extra?: {
              [key: string]: unknown;
          };
          /**
           * @description Update the chat-composer trigger alias. Same validation and
           *     uniqueness rules as on create. 422 on collision.
           */
          slash_alias?: string | null;
      };
      TeamSummary: {
          /** Format: uuid */
          id: string;
          slug: string;
          name: string;
          description?: string | null;
          /** Format: uuid */
          created_by_user_id: string;
          /** Format: date-time */
          created_at: string;
          /** Format: date-time */
          updated_at: string;
          member_count?: number;
          /**
           * @description The caller's role on this team (D8.1c). Populated by the
           *     user-facing ``GET /api/v1/teams`` and
           *     ``GET /api/v1/teams/{id}`` endpoints. Null on operator-admin
           *     views (``/admin/teams``) when the admin isn't a member.
           * @enum {string|null}
           */
          caller_role?: "admin" | "member" | null;
      };
      TeamMember: {
          /** Format: uuid */
          user_id: string;
          email: string;
          display_name?: string | null;
          /** @enum {string} */
          role: "admin" | "member";
          /** Format: uuid */
          added_by_user_id: string;
          /** Format: date-time */
          created_at: string;
      };
      Team: components["schemas"]["TeamSummary"] & {
          members?: components["schemas"]["TeamMember"][];
      };
      TeamCreate: {
          slug: string;
          name: string;
          description?: string | null;
      };
      TeamUpdate: {
          name?: string;
          description?: string | null;
      };
      AuditLogEntry: {
          /** Format: uuid */
          id: string;
          /** Format: date-time */
          timestamp: string;
          /** Format: uuid */
          user_id?: string | null;
          /** @description e.g. chat.create, message.send, skill.fork */
          action: string;
          /** @description e.g. chat, project, skill */
          resource_type: string;
          resource_id?: string | null;
          privilege_marked?: boolean;
          /** @description Why this entry was marked privileged */
          privilege_basis?: string | null;
          /** @enum {integer|null} */
          routed_inference_tier?: 1 | 2 | 3 | 4 | 5 | null;
          ip_address?: string | null;
          user_agent?: string | null;
          details?: {
              [key: string]: unknown;
          };
      };
      TierPolicy: {
          /** @description Tiers globally allowed; requests at other tiers refused */
          allowed_tiers_global: (1 | 2 | 3 | 4 | 5)[];
          /**
           * @description Default minimum tier for non-privileged work
           * @enum {integer}
           */
          default_minimum_tier: 1 | 2 | 3 | 4 | 5;
          /**
           * @description Minimum tier when privileged: true on Project
           * @enum {integer}
           */
          privileged_minimum_tier?: 1 | 2 | 3 | 4 | 5;
          /** @description Tiers that surface a warning in the chat UI */
          warn_on_tiers?: (1 | 2 | 3 | 4 | 5)[];
      };
      AdminAliasFallback: {
          provider: string;
          model: string;
      };
      AdminAliasEntry: {
          name: string;
          provider: string;
          model: string;
          fallback: components["schemas"]["AdminAliasFallback"][];
          /** @enum {integer} */
          primary_inference_tier?: 1 | 2 | 3 | 4 | 5;
      };
      AdminAliasCreate: {
          name: string;
          provider: string;
          model: string;
          fallback?: components["schemas"]["AdminAliasFallback"][];
      };
      AdminAliasUpdate: {
          provider: string;
          model: string;
          fallback?: components["schemas"]["AdminAliasFallback"][];
      };
      ProviderKeySetRequest: {
          /** @description Name of an already-configured provider entry. */
          provider: string;
          /**
           * @description Plaintext provider key. The gateway encrypts it with the
           *     gateway master key before it touches disk; it is never echoed
           *     back in any response.
           */
          api_key: string;
      };
      ProviderKeyRotateRequest: {
          /**
           * @description Replacement plaintext provider key. Same handling as
           *     ProviderKeySetRequest.api_key.
           */
          api_key: string;
      };
      MCPToolView: {
          name: string;
          description?: string | null;
          parameters?: {
              [key: string]: unknown;
          };
          read_only: boolean;
          destructive: boolean;
          requires_confirmation: boolean;
          enabled: boolean;
      };
      MCPServerView: {
          name: string;
          type: string;
          /**
           * @description Authentication mode for this MCP server. One of ``none``,
           *     ``bearer``, or ``oauth``. Read from the gateway config
           *     ``auth`` field; defaults to ``none`` when absent.
           * @enum {string}
           */
          auth: "none" | "bearer" | "oauth";
          tools: components["schemas"]["MCPToolView"][];
      };
      MCPServersResponse: {
          servers: components["schemas"]["MCPServerView"][];
      };
      MCPRefreshResponse: {
          server: string;
          tools: components["schemas"]["MCPToolView"][];
      };
      MCPToolEnableRequest: {
          enabled: boolean;
      };
      MCPOAuthCallbackResponse: {
          connected: boolean;
          server: string;
          scopes: string[];
          /** Format: date-time */
          expires_at?: string | null;
      };
      MCPOAuthStatusResponse: {
          connected: boolean;
          scopes: string[];
          /** Format: date-time */
          expires_at?: string | null;
      };
      /**
       * @description PR4d Ask 1. Per-server OAuth connection status for a single user.
       *     Token bytes are never included.
       */
      MCPOAuthServerStatus: {
          server: string;
          connected: boolean;
          scopes: string[];
          /** Format: date-time */
          expires_at?: string | null;
      };
      /**
       * @description PR4d Ask 1. Response body for GET /api/v1/mcp/oauth — list of all
       *     connectable OAuth MCP servers with the calling user's connection state.
       */
      MCPOAuthServersResponse: {
          servers: components["schemas"]["MCPOAuthServerStatus"][];
      };
      /**
       * @description Secret-safe status for one provider. Carries at most the last 4
       *     characters of the resolved key — never the full key or token.
       */
      ProviderKeyStatus: {
          provider: string;
          /**
           * @description The provider's adapter type. Null only in the rare race where a
           *     provider is removed between the write and the status read-back on
           *     a single-provider (POST/PATCH) response; never null on the list.
           */
          type: string | null;
          /**
           * @description True when the provider has a live, routable adapter (its key
           *     resolved). A keyless or unresolvable provider is false.
           */
          configured: boolean;
          /**
           * @description Last 4 characters of the resolved key, or null when the key is
           *     absent, unresolvable, or shorter than 4 characters.
           */
          last4: string | null;
          /**
           * @description Key source: `runtime` (encrypted-at-rest in gateway.yaml),
           *     `env` (api_key_env), or null (no key configured).
           * @enum {string|null}
           */
          source: "env" | "runtime" | null;
      };
      ProviderKeyList: {
          provider_keys: components["schemas"]["ProviderKeyStatus"][];
      };
      ToolCallDecisionRequest: {
          /**
           * @description Whether to approve or deny the pending tool call.
           * @enum {string}
           */
          decision: "approve" | "deny";
      };
      /**
       * @description Canonical structured error envelope returned by every backend
       *     endpoint that raises a typed error (`LQAIError` subclass).
       *     Implemented by the FastAPI exception handler in
       *     `api/app/main.py`; per ADR 0003 the wrapper key is `detail`
       *     (matching FastAPI's native `HTTPException` response and the
       *     existing B2 forced-password-change pattern). The inner shape
       *     — `code` + `message` + `details` — is the load-bearing
       *     contract and matches the shape the gateway uses on its side
       *     under the `error` wrapper (see gateway-openapi.yaml's
       *     `GatewayError`).
       *
       *     The pre-existing 501 stub envelope (returned by un-implemented
       *     endpoints during M1 buildout, A4 scaffold) uses the legacy
       *     `{"error": {...}}` wrapper instead. Each stub is replaced by a
       *     real handler as its M1 task lands; new typed errors all use
       *     the `detail` wrapper above.
       */
      Error: {
          detail: {
              /**
               * @description Stable error code. Backend-only codes:
               *     `password_change_required`, `payload_too_large`,
               *     `conflict`, `unauthorized`, `forbidden`, `not_found`,
               *     `validation_error`, `rate_limited`, `internal_error`.
               *     Backend↔gateway crossing codes (propagated from gateway
               *     responses):
               *     `gateway_unreachable`, `gateway_timeout`,
               *     `gateway_invalid_response`, `provider_unavailable`,
               *     `tier_below_minimum`, `invalid_model`,
               *     `skill_not_found`, `skill_fetch_failed`,
               *     `skill_input_missing` (C2).
               * @enum {string}
               */
              code: "password_change_required" | "payload_too_large" | "conflict" | "unauthorized" | "forbidden" | "not_found" | "validation_error" | "rate_limited" | "internal_error" | "gateway_unreachable" | "gateway_timeout" | "gateway_invalid_response" | "provider_unavailable" | "tier_below_minimum" | "invalid_model" | "skill_not_found" | "skill_fetch_failed" | "skill_input_missing";
              message: string;
              details?: {
                  [key: string]: unknown;
              };
          };
      };
  };
  responses: never;
  parameters: never;
  requestBodies: never;
  headers: never;
  pathItems: never;
12032}
12033export type $defs = Record<string, never>;
12034export type operations = Record<string, never>;
12035