Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

209 KB
Raw Blame
/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

/** Branded string type — compile-time only. */
type TypedString<T extends string> = string & { __brand: T };

export interface paths {
  "/@file/{filename_and_length}": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path: {
          /** @description The filename and byte length of the virtual file */
          filename_and_length: string;
        };
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Get a virtual file */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/octet-stream": string;
          };
        };
        /** @description Invalid byte length in virtual file request */
        404: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/ai/chat": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      /** @description The request body for AI chat */
      requestBody: {
        content: {
          "application/json": components["schemas"]["ChatRequest"];
        };
      };
      responses: never;
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/ai/completion": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      /** @description The request body for AI completion */
      requestBody: {
        content: {
          "application/json": components["schemas"]["AiCompletionRequest"];
        };
      };
      responses: {
        /** @description Get AI completion for a prompt */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": {
              [key: string]: unknown;
            };
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/ai/inline_completion": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      /** @description The request body for AI inline completion */
      requestBody: {
        content: {
          "application/json": components["schemas"]["AiInlineCompletionRequest"];
        };
      };
      responses: {
        /** @description Get AI inline completion for code */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "text/plain": string;
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/ai/invoke_tool": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      /** @description The request body for tool invocation */
      requestBody: {
        content: {
          "application/json": components["schemas"]["InvokeAiToolRequest"];
        };
      };
      responses: {
        /** @description Tool invocation result */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["InvokeAiToolResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/ai/mcp/refresh": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Refresh MCP server configuration */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["MCPRefreshResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/ai/mcp/status": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Get MCP server status */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["MCPStatusResponse"];
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/cache/clear": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ClearCacheRequest"];
        };
      };
      responses: {
        /** @description Clear all caches */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/cache/info": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["GetCacheInfoRequest"];
        };
      };
      responses: {
        /** @description Get cache statistics */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/datasources/discover": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody: {
        content: {
          "application/json": components["schemas"]["DiscoverDataSourcesRequest"];
        };
      };
      responses: {
        /** @description Discover datasource connections */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/datasources/preview_column": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PreviewDatasetColumnRequest"];
        };
      };
      responses: {
        /** @description Preview a column in a dataset */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/datasources/preview_datasource_connection": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ListDataSourceConnectionRequest"];
        };
      };
      responses: {
        /** @description Broadcasts a datasource connection */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/datasources/preview_sql_schema_list": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ListSQLSchemasRequest"];
        };
      };
      responses: {
        /** @description Preview a list of schemas in an SQL database */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/datasources/preview_sql_table": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["PreviewSQLTableRequest"];
        };
      };
      responses: {
        /** @description Preview a SQL table */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/datasources/preview_sql_table_list": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ListSQLTablesRequest"];
        };
      };
      responses: {
        /** @description Preview a list of tables in an SQL schema */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/documentation/snippets": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Load the snippets for the documentation page */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["Snippets"];
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/environment": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Environment information for issue reporting */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": {
              Binaries: {
                [key: string]: string;
              };
              Dependencies: {
                [key: string]: string;
              };
              "Experimental Flags": {
                [key: string]: unknown;
              };
              Locale: string;
              OS: string;
              "OS Version": string;
              "Optional Dependencies": {
                [key: string]: string;
              };
              Processor: string;
              "Python Version": string;
              editable: boolean;
              location: string;
              marimo: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/auto_export/html": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ExportAsHTMLRequest"];
        };
      };
      responses: {
        /** @description Export the notebook as HTML */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
        /** @description File must be saved before downloading */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/auto_export/ipynb": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["AutoExportAsIPYNBRequest"];
        };
      };
      responses: {
        /** @description Export the notebook as IPYNB */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
        /** @description File must be saved before downloading */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/auto_export/markdown": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["AutoExportAsMarkdownRequest"];
        };
      };
      responses: {
        /** @description Export the notebook as a markdown */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
        /** @description File must be saved before downloading */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/availability": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Readiness for server-backed exports */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ExportAvailabilityResponse"];
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/html": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ExportAsHTMLRequest"];
        };
      };
      responses: {
        /** @description Export the notebook as HTML */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "text/html": string;
          };
        };
        /** @description File must be saved before downloading */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/ipynb": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ExportAsIPYNBRequest"];
        };
      };
      responses: {
        /** @description Export the notebook as IPYNB */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "text/plain": string;
          };
        };
        /** @description File must be saved before downloading */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/markdown": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ExportAsMarkdownRequest"];
        };
      };
      responses: {
        /** @description Export the notebook as a markdown */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "text/plain": string;
          };
        };
        /** @description File must be saved before downloading */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/pdf": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ExportAsPDFRequest"];
        };
      };
      responses: {
        /** @description Export the notebook as a PDF */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/pdf": string;
          };
        };
        /** @description File must be saved before downloading */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
        /** @description Export failed or dependencies missing */
        500: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/requirements/install": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["InstallExportRequirementsRequest"];
        };
      };
      responses: {
        /** @description Updated readiness for server-backed exports */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ExportAvailabilityResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/script": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ExportAsScriptRequest"];
        };
      };
      responses: {
        /** @description Export the notebook as a script */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "text/plain": string;
          };
        };
        /** @description Invalid export request */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/export/update_cell_outputs": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["UpdateCellOutputsRequest"];
        };
      };
      responses: {
        /** @description Update the cell outputs */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
        /** @description File must be saved before downloading */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/copy": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FileCopyRequest"];
        };
      };
      responses: {
        /** @description Copy a file or directory */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FileCopyResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/create": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "multipart/form-data": components["schemas"]["FileCreateMultipartRequest"];
        };
      };
      responses: {
        /** @description Create a new file or directory */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FileCreateResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/delete": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FileDeleteRequest"];
        };
      };
      responses: {
        /** @description Delete a file or directory */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FileDeleteResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/download": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query: {
          /** @description Path of the file to download */
          path: string;
        };
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Stream the file as an attachment */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/octet-stream": string;
          };
        };
        /** @description Path is missing or is a directory */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
        /** @description File downloads are disabled */
        403: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
        /** @description File not found */
        404: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/file_details": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FileDetailsRequest"];
        };
      };
      responses: {
        /** @description Get details of a specific file or directory */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FileDetailsResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/list_files": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FileListRequest"];
        };
      };
      responses: {
        /** @description List files and directories in a given path */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FileListResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/move": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FileMoveRequest"];
        };
      };
      responses: {
        /** @description Move a file or directory */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FileMoveResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/open": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FileOpenRequest"];
        };
      };
      responses: {
        /** @description Open a file in the system editor */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BaseResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/roots": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description List roots shown in the file browser */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FileRootsResponse"];
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/search": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FileSearchRequest"];
        };
      };
      responses: {
        /** @description Search for files and directories matching a query */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FileSearchResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/files/update": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FileUpdateRequest"];
        };
      };
      responses: {
        /** @description Update a file or directory */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FileUpdateResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/home/recent_files": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Get the recent files */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["RecentFilesResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/home/running_notebooks": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Get the running files */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["RunningNotebooksResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/home/shutdown_session": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ShutdownSessionRequest"];
        };
      };
      responses: {
        /** @description Shutdown the current session */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["RunningNotebooksResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/home/tutorial/open": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["OpenTutorialRequest"];
        };
      };
      responses: {
        /** @description Open a new tutorial */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["MarimoFile"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/home/workspace_files": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["WorkspaceFilesRequest"];
        };
      };
      responses: {
        /** @description Get the files in the workspace */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["WorkspaceFilesResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/code_autocomplete": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["CodeCompletionRequest"];
        };
      };
      responses: {
        /** @description Complete a code fragment */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/copy": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["CopyNotebookRequest"];
        };
      };
      responses: {
        /** @description Copy notebook */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "text/plain": string;
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/focus_cell": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FocusCellRequest"];
        };
      };
      responses: {
        /** @description Focus a cell in kiosk-mode consumers */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/format": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["FormatCellsRequest"];
        };
      };
      responses: {
        /** @description Format code */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["FormatResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/function_call": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["InvokeFunctionRequest"];
        };
      };
      responses: {
        /** @description Invoke an RPC */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/install_missing_packages": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["InstallPackagesRequest"];
        };
      };
      responses: {
        /** @description Install missing packages */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/instantiate": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["InstantiateNotebookRequest"];
        };
      };
      responses: {
        /** @description Instantiate a component. Only allowed in edit mode; in run mode, instantiation happens server-side automatically. */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/interrupt": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Interrupt the kernel's execution */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/pdb/breakpoints": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SetBreakpointsRequest"];
        };
      };
      responses: {
        /** @description Set the live debugger's breakpoints for the session. */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/pdb/pm": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["DebugCellRequest"];
        };
      };
      responses: {
        /** @description Run a post mortem on the most recent failed cell. */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/read_code": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Read the code from the server */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ReadCodeResponse"];
          };
        };
        /** @description File must be saved before downloading */
        400: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
        /** @description Code is not available in run mode */
        403: {
          headers: {
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/rename": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["RenameNotebookRequest"];
        };
      };
      responses: {
        /** @description Rename the current app */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/restart_session": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Restart the current session without affecting other sessions. */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/run": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ExecuteCellsRequest"];
        };
      };
      responses: {
        /** @description Run a cell. Updates cell code in the kernel if needed; registers new cells for unseen cell IDs. Only allowed in edit mode. */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/save_app_config": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SaveAppConfigurationRequest"];
        };
      };
      responses: {
        /** @description Save the app configuration */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "text/plain": string;
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/save_layout": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SaveLayoutRequest"];
        };
      };
      responses: {
        /** @description Write the notebook's layout file and point its app config at it */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/save_user_config": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: {
          "Marimo-Session-Id"?: string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["SaveUserConfigurationRequest"];
        };
      };
      responses: {
        /** @description Update the user config on disk and in the kernel. Only allowed in edit mode. */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/scratchpad/run": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ExecuteScratchpadRequest"];
        };
      };
      responses: {
        /** @description Run the scratchpad */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/set_model_value": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ModelRequest"];
        };
      };
      responses: {
        /** @description Set model value */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/set_ui_element_value": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["UpdateUIElementValuesRequest"];
        };
      };
      responses: {
        /** @description Set UI element values */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/shutdown": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: {
          "Marimo-Session-Id"?: string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Shutdown the kernel */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/status": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Report whether the kernel is currently executing. `running` means at least one cell is queued or running; `idle` means the kernel is alive but not executing; `stopped` means the kernel process is not running. */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["KernelStatusResponse"];
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/stdin": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["StdinRequest"];
        };
      };
      responses: {
        /** @description Send input to the stdin stream */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/kernel/takeover": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Successfully closed existing sessions */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": {
              status?: string;
            };
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/lsp/health": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Get health status of all LSP servers */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["LspHealthResponse"];
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/lsp/restart": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["LspRestartRequest"];
        };
      };
      responses: {
        /** @description Restart LSP servers */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["LspRestartResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/packages/add": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["AddPackageRequest"];
        };
      };
      responses: {
        /** @description Install package */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["PackageOperationResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/packages/list": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description List installed packages */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ListPackagesResponse"];
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/packages/manifest": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody: {
        content: {
          "application/json": components["schemas"]["UpdateManifestRequest"];
        };
      };
      responses: {
        /** @description Save notebook metadata without changing its cells */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SandboxResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/packages/remove": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["RemovePackageRequest"];
        };
      };
      responses: {
        /** @description Uninstall package */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["PackageOperationResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/packages/sandbox": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody: {
        content: {
          "application/json": components["schemas"]["SandboxRequest"];
        };
      };
      responses: {
        /** @description Sandbox manifest, available before kernel startup */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SandboxResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/packages/sync": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody: {
        content: {
          "application/json": components["schemas"]["SandboxRequest"];
        };
      };
      responses: {
        /** @description Apply the saved manifest, or reconnect to retry startup */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SyncSandboxResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/packages/tree": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description List dependency tree */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["DependencyTreeResponse"];
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/secrets/create": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody: {
        content: {
          "application/json": components["schemas"]["CreateSecretRequest"];
        };
      };
      responses: {
        /** @description Create a secret */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BaseResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/secrets/delete": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Delete a secret */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["BaseResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/secrets/keys": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody: {
        content: {
          "application/json": components["schemas"]["ListSecretKeysRequest"];
        };
      };
      responses: {
        /** @description List all secret keys */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["ListSecretKeysResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/sql/validate": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["ValidateSQLRequest"];
        };
      };
      responses: {
        /** @description Validate an SQL query */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/status": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Get the status of the application */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": {
              filenames?: string[];
              lsp_running?: boolean;
              mode?: string;
              node_version?: string;
              requirements?: string[];
              sessions?: number;
              status?: string;
              version?: string;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/status/connections": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Get the number of active websocket connections */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": {
              active?: number;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/storage/download": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["StorageDownloadRequest"];
        };
      };
      responses: {
        /** @description Download a storage entry */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/storage/list_entries": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    post: {
      parameters: {
        query?: never;
        header: {
          "Marimo-Session-Id": string;
        };
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/json": components["schemas"]["StorageListEntriesRequest"];
        };
      };
      responses: {
        /** @description List storage entries at a prefix */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": components["schemas"]["SuccessResponse"];
          };
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/usage": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Get the current memory and CPU usage of the application */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": {
              cpu: {
                percent: number;
              };
              gpu?: {
                index: number;
                memory: {
                  free: number;
                  percent: number;
                  total: number;
                  used: number;
                };
                name: string;
              }[];
              kernel?: {
                memory?: number;
              };
              memory: {
                available: number;
                free: number;
                has_cgroup_mem_limit: boolean;
                percent: number;
                total: number;
                used: number;
              };
              server?: {
                memory: number;
              };
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/api/version": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description Get the version of the application */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "text/plain": string;
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/auth/login": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    /** Submit login form */
    post: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: {
        content: {
          "application/x-www-form-urlencoded": {
            /** @description Access token or password */
            password?: string;
          };
        };
      };
      responses: {
        /** @description Login page */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "text/html": string;
          };
        };
        /** @description Redirect to the next URL */
        302: {
          headers: {
            Location?: string;
            [name: string]: unknown;
          };
          content?: never;
        };
      };
    };
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/auth/token": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** Get the auth token for the current session */
    get: {
      parameters: {
        query?: never;
        header?: never;
        path?: never;
        cookie?: never;
      };
      requestBody?: never;
      responses: {
        /** @description The auth token (null if auth is disabled) */
        200: {
          headers: {
            [name: string]: unknown;
          };
          content: {
            "application/json": {
              token?: string | null;
            };
          };
        };
      };
    };
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
}
export type webhooks = Record<string, any>;
export interface components {
  schemas: {
    /**
     * ActiveLineNotification
     * @description Reports the line a cell's frame watcher is currently executing.
     *
     *         Emitted on a timed heartbeat while a cell runs (only when the line
     *         changed), so the editor can highlight the live line. A `None` line
     *         clears the highlight (e.g. when the cell finishes).
     *
     *         Attributes:
     *             cell_id: Cell whose frame is being watched.
     *             line: 1-based line within the cell, or `None` to clear.
     */
    ActiveLineNotification: {
      cell_id: components["schemas"]["CellId"];
      /** @default null */
      line?: number | null;
      /** @enum {unknown} */
      op: "active-line";
    };
    /**
     * AddPackageRequest
     * @description This can be a remove package or a local package.
     *
     *     Supported formats:
     *
     *     httpx
     *     httpx==0.27.0
     *     httpx>=0.27.0
     *     git+https://github.com/encode/httpx
     *     https://files.pythonhosted.org/packages/5c/2d/3da5bdf4408b8b2800061c339f240c1802f2e82d55e50bd39c5a881f47f0/httpx-0.27.0.tar.gz
     *     /example/foo-0.1.0-py3-none-any.whl
     */
    AddPackageRequest: {
      /** @default null */
      group?: string | null;
      package: string;
      /** @default false */
      upgrade?: boolean | null;
    };
    /** AiCompletionContext */
    AiCompletionContext: {
      /** @default  */
      plainText?: string;
      /** @default [] */
      schema?: components["schemas"]["SchemaTable"][];
      /** @default [] */
      variables?: (string | components["schemas"]["VariableContext"])[];
    };
    /**
     * AiCompletionRequest
     * @description UIMessages are expected to be AI SDK messages.
     *     See pydantic_ai.ui.vercel_ai.request_types.UIMessage or Vercel AI SDK documentation.
     */
    AiCompletionRequest: {
      code: string;
      /** @default null */
      context?: components["schemas"]["AiCompletionContext"] | null;
      /** @default null */
      id?: string | null;
      includeOtherCode: string;
      /**
       * @default python
       * @enum {unknown}
       */
      language?: "markdown" | "python" | "sql";
      prompt: string;
      /** @default null */
      selectedText?: string | null;
      /** @default [] */
      uiMessages?: Record<string, any>[];
    };
    /**
     * AiConfig
     * @description Configuration options for AI.
     *
     *         **Keys.**
     *
     *         - `enabled`: if `False`, hide AI actions and panels in the marimo UI
     *         - `rules`: custom rules to include in all AI completion prompts
     *         - `max_tokens`: the maximum number of tokens to use in AI completions
     *         - `mode`: notebook access for the built-in assistant: `"ask"` (read only), `"agent"` (suggest edits), or `"code_mode"` (full access). Defaults to `"ask"`.
     *         - `inline_tooltip`: if `True`, enable inline AI tooltip suggestions
     *         - `allow_provider_config`: if `False`, lock provider setup in the settings UI, making them read-only. Users cannot bring their own credentials or add custom providers. Default `True`.
     *         - `models`: the models to use for AI completions
     *         - `open_ai`: the OpenAI config
     *         - `anthropic`: the Anthropic config
     *         - `google`: the Google AI config
     *         - `bedrock`: the Bedrock config
     *         - `azure`: the Azure config
     *         - `ollama`: the Ollama config
     *         - `github`: the GitHub Copilot config
     *         - `openrouter`: the OpenRouter config
     *         - `wandb`: the Weights & Biases config
     *         - `opencode_go`: the OpenCode Go config
     *         - `custom_providers`: a dict of custom OpenAI-compatible providers
     *         - `open_ai_compatible`: the OpenAI-compatible config (deprecated, use custom_providers)
     */
    AiConfig: {
      allow_provider_config?: boolean;
      anthropic?: components["schemas"]["AnthropicConfig"];
      azure?: components["schemas"]["OpenAiConfig"];
      bedrock?: components["schemas"]["BedrockConfig"];
      custom_providers?: {
        [key: string]: components["schemas"]["OpenAiConfig"];
      };
      enabled?: boolean;
      github?: components["schemas"]["GitHubConfig"];
      google?: components["schemas"]["GoogleAiConfig"];
      inline_tooltip?: boolean;
      max_tokens?: number;
      /** @enum {unknown} */
      mode?: "agent" | "ask" | "code_mode" | "manual";
      models?: components["schemas"]["AiModelConfig"];
      ollama?: components["schemas"]["OpenAiConfig"];
      open_ai?: components["schemas"]["OpenAiConfig"];
      open_ai_compatible?: components["schemas"]["OpenAiConfig"];
      opencode_go?: components["schemas"]["OpenAiConfig"];
      openrouter?: components["schemas"]["OpenAiConfig"];
      rules?: string;
      wandb?: components["schemas"]["OpenAiConfig"];
    };
    /** AiInlineCompletionRequest */
    AiInlineCompletionRequest: {
      /**
       * @default python
       * @enum {unknown}
       */
      language?: "markdown" | "python" | "sql";
      prefix: string;
      suffix: string;
    };
    /**
     * AiModelConfig
     * @description Configuration options for an AI model.
     *
     *         **Keys.**
     *
     *         - `chat_model`: the model to use for chat completions
     *         - `edit_model`: the model to use for edit completions
     *         - `autocomplete_model`: the model to use for code completion/autocomplete
     *         - `displayed_models`: a list of models to display in the UI
     *         - `custom_models`: a list of custom models to use that are not from the default list
     */
    AiModelConfig: {
      autocomplete_model?: string;
      chat_model?: string;
      custom_models: string[];
      displayed_models: string[];
      edit_model?: string;
    };
    /**
     * AlertNotification
     * @description User-facing alert message.
     *
     *         Attributes:
     *             title: Alert title.
     *             description: Alert body (may contain HTML).
     *             variant: Visual variant (e.g., "danger").
     */
    AlertNotification: {
      description: string;
      /** @enum {unknown} */
      op: "alert";
      title: string;
      /** @default null */
      variant?: "danger" | null;
    };
    /**
     * AnthropicConfig
     * @description Configuration options for Anthropic.
     *
     *         **Keys.**
     *
     *         - `api_key`: the Anthropic API key or an `env:` reference
     */
    AnthropicConfig: {
      api_key?: string;
    };
    /** AutoExportAsIPYNBRequest */
    AutoExportAsIPYNBRequest: {
      download: boolean;
    };
    /** AutoExportAsMarkdownRequest */
    AutoExportAsMarkdownRequest: {
      download: boolean;
    };
    /**
     * BannerNotification
     * @description Persistent banner message at top of notebook.
     *
     *         Attributes:
     *             title: Banner title.
     *             description: Banner body (may contain HTML).
     *             variant: Visual variant (e.g., "danger").
     *             action: Optional user action (e.g., "restart").
     */
    BannerNotification: {
      /** @default null */
      action?: "restart" | null;
      description: string;
      /** @enum {unknown} */
      op: "banner";
      title: string;
      /** @default null */
      variant?: "danger" | null;
    };
    /** Format: base64 */
    Base64String: TypedString<"Base64String">;
    /** BaseResponse */
    BaseResponse: {
      success: boolean;
    };
    /**
     * BasedpyrightServerConfig
     * @description Configuration options for basedpyright Language Server.
     *
     *     basedpyright handles completion, hover, go-to-definition, and diagnostics,
     *     but we only use it for diagnostics.
     */
    BasedpyrightServerConfig: {
      enabled?: boolean;
    };
    /**
     * BedrockConfig
     * @description Configuration options for Bedrock.
     *
     *         **Keys.**
     *
     *         - `profile_name`: the AWS profile to use
     *         - `region_name`: the AWS region to use
     *         - `aws_access_key_id`: the AWS access key ID
     *         - `aws_secret_access_key`: the AWS secret access key
     */
    BedrockConfig: {
      aws_access_key_id?: string;
      aws_secret_access_key?: string;
      profile_name?: string;
      region_name?: string;
    };
    /**
     * CacheClearedNotification
     * @description Execution cache cleared result.
     *
     *         Attributes:
     *             bytes_freed: Bytes freed by clearing cache.
     */
    CacheClearedNotification: {
      bytes_freed: number;
      /** @enum {unknown} */
      op: "cache-cleared";
    };
    /**
     * CacheConfig
     * @description Configuration for caching.
     *
     *         `verification` is the signature-checking posture; `store` is the backing
     *         store, or a list of stores composed into a `TieredStore`; `loader` is the
     *         default `method` for `mo.persistent_cache`.
     */
    CacheConfig: {
      loader?: ("json" | "lazy" | "pickle") | string;
      store?:
        | components["schemas"]["StoreConfig"][]
        | components["schemas"]["StoreConfig"];
      /** @enum {unknown} */
      verification?: "off" | "on" | "strict";
    };
    /**
     * CacheInfoNotification
     * @description Execution cache statistics.
     *
     *         Attributes:
     *             hits: Cache hits.
     *             misses: Cache misses.
     *             time: Time spent on cache operations (seconds).
     *             disk_to_free: Disk space that could be freed (bytes).
     *             disk_total: Total disk space used (bytes).
     */
    CacheInfoNotification: {
      disk_to_free: number;
      disk_total: number;
      hits: number;
      misses: number;
      /** @enum {unknown} */
      op: "cache-info";
      time: number;
    };
    /**
     * CellChannel
     * @description The channel of a cell's output.
     * @enum {unknown}
     */
    CellChannel:
      | "marimo-error"
      | "media"
      | "output"
      | "pdb"
      | "stderr"
      | "stdin"
      | "stdout";
    /**
     * CellConfig
     * @description Internal representation of a cell's configuration.
     *     This is not part of the public API.
     */
    CellConfig: {
      /** @default null */
      column?: number | null;
      /** @default false */
      disabled?: boolean;
      /** @default false */
      expand_output?: boolean;
      /** @default false */
      hide_code?: boolean;
    };
    /** Format: cell-id */
    CellId: TypedString<"CellId">;
    /**
     * CellNotification
     * @description Updates a cell's state in the frontend.
     *
     *         This is a partial update: each field carries its own "unchanged" semantics,
     *         documented per field below. Most fields treat None as "unchanged"; fields
     *         that need to distinguish "unchanged" from "clear" use msgspec.UNSET for the
     *         former and None for the latter.
     *
     *         Attributes:
     *             cell_id: Unique identifier of the cell being updated.
     *             output: Cell's output. Use CellOutput.empty() to clear.
     *             console: Console messages. Single/list appends, [] clears, None unchanged.
     *             status: Execution status (idle/running/stale/queued/disabled-transitively).
     *             stale_inputs: Whether cell has stale inputs from changed dependencies.
     *             run_id: Execution run ID for tracing. Auto-set from context.
     *             execution_id: Evaluation of this cell producing the update, when known.
     *             serialization: Top-level reusability hint. UNSET unchanged, None clears, str sets.
     *             timestamp: Creation timestamp, auto-set.
     */
    CellNotification: {
      cell_id: components["schemas"]["CellId"];
      /** @default null */
      console?:
        | components["schemas"]["CellOutput"][]
        | components["schemas"]["CellOutput"]
        | null;
      /** @default null */
      execution_id?: string | null;
      /** @enum {unknown} */
      op: "cell-op";
      /** @default null */
      output?: components["schemas"]["CellOutput"] | null;
      /** @default null */
      run_id?: string | null;
      serialization?: string | null;
      /** @default null */
      stale_inputs?: boolean | null;
      /** @default null */
      status?: ("disabled-transitively" | "idle" | "queued" | "running") | null;
      timestamp?: number;
    };
    /** CellOutput */
    CellOutput: {
      channel: components["schemas"]["CellChannel"];
      code?: string;
      data:
        | string
        | (
            | components["schemas"]["SetupRootError"]
            | components["schemas"]["CycleError"]
            | components["schemas"]["MultipleDefinitionError"]
            | components["schemas"]["ImportStarError"]
            | components["schemas"]["LazyImportError"]
            | components["schemas"]["MarimoAncestorStoppedError"]
            | components["schemas"]["MarimoAncestorPreventedError"]
            | components["schemas"]["MarimoExceptionRaisedError"]
            | components["schemas"]["MarimoStrictExecutionError"]
            | components["schemas"]["MarimoInterruptionError"]
            | components["schemas"]["MarimoSyntaxError"]
            | components["schemas"]["MarimoInternalError"]
            | components["schemas"]["MarimoSQLError"]
            | components["schemas"]["UnknownError"]
          )[]
        | Record<string, any>;
      /** @enum {unknown} */
      mimetype:
        | "application/json"
        | "application/vnd.jupyter.widget-view+json"
        | "application/vnd.marimo+error"
        | "application/vnd.marimo+mimebundle"
        | "application/vnd.marimo+traceback"
        | "application/vnd.vega.v5+json"
        | "application/vnd.vega.v6+json"
        | "application/vnd.vegalite.v5+json"
        | "application/vnd.vegalite.v6+json"
        | "image/avif"
        | "image/bmp"
        | "image/gif"
        | "image/jpeg"
        | "image/png"
        | "image/svg+xml"
        | "image/tiff"
        | "text/csv"
        | "text/html"
        | "text/latex"
        | "text/markdown"
        | "text/password"
        | "text/plain"
        | "video/mp4"
        | "video/mpeg";
      timestamp?: number;
      /** @enum {unknown} */
      traceback_format?: "html" | "text";
    };
    /**
     * CellOutputs
     * @description Per-cell output snapshot delivered alongside the document snapshot.
     *
     *         `output` carries the cell's last main (rich display) output;
     *         `console_outputs` carries the buffered stdout/stderr stream from
     *         its last execution.  Both are keyed by cell id; missing keys mean
     *         "no output captured" (the cell never ran, or produced nothing on
     *         that channel).
     */
    CellOutputs: {
      console_outputs: {
        [key: string]: components["schemas"]["CellOutput"][];
      };
      output: {
        [key: string]: components["schemas"]["CellOutput"];
      };
    };
    /** ChatAttachment */
    ChatAttachment: {
      /** @default null */
      content_type?: string | null;
      /** @default attachment */
      name?: string;
      url: string;
    };
    /**
     * ChatMessage
     * @description A message in a chat.
     */
    ChatMessage: {
      /** @default null */
      attachments?: components["schemas"]["ChatAttachment"][] | null;
      content: unknown;
      /** @default  */
      id?: string;
      /** @default null */
      metadata?: unknown | null;
      /** @default [] */
      parts?: Record<string, any>[];
      /** @enum {unknown} */
      role: "assistant" | "system" | "user";
    };
    /**
     * ChatOptions
     * @description Used to configure capabilities of the AI agent.
     */
    ChatOptions: {
      /** @default false */
      webSearch?: boolean;
    };
    /**
     * ChatRequest
     * @description UIMessages are expected to be AI SDK messages.
     *     See pydantic_ai.ui.vercel_ai.request_types.UIMessage or Vercel AI SDK documentation.
     */
    ChatRequest: {
      /** @default null */
      id?: string | null;
      includeOtherCode: string;
      /** @default null */
      model?: string | null;
      options?: components["schemas"]["ChatOptions"];
      /** @default null */
      tools?: components["schemas"]["ToolDefinition"][] | null;
      uiMessages: Record<string, any>[];
      /** @default null */
      variables?: (string | components["schemas"]["VariableContext"])[] | null;
    };
    /** ClearCacheRequest */
    ClearCacheRequest: Record<string, any>;
    ClientCommand:
      | components["schemas"]["ExecuteCellsCommand"]
      | components["schemas"]["ExecuteScratchpadCommand"]
      | components["schemas"]["DeleteCellCommand"]
      | components["schemas"]["UpdateCellConfigCommand"]
      | components["schemas"]["UpdateUIElementCommand"]
      | components["schemas"]["ModelCommand"]
      | components["schemas"]["InvokeFunctionCommand"]
      | components["schemas"]["InstallPackagesCommand"]
      | components["schemas"]["PreviewDatasetColumnCommand"]
      | components["schemas"]["PreviewSQLTableCommand"]
      | components["schemas"]["ListSQLTablesCommand"]
      | components["schemas"]["ListSQLSchemasCommand"]
      | components["schemas"]["ValidateSQLCommand"]
      | components["schemas"]["ListDataSourceConnectionCommand"]
      | components["schemas"]["DiscoverDataSourcesCommand"]
      | components["schemas"]["ListSecretKeysCommand"];
    /** CodeCompletionRequest */
    CodeCompletionRequest: {
      cellId: components["schemas"]["CellId"];
      document: string;
      id: components["schemas"]["RequestId"];
    };
    /**
     * ColumnStats
     * @description Represents stats for a column in a data table.
     */
    ColumnStats: {
      /** @default null */
      false?: number | null;
      /** @default null */
      max?: unknown | null;
      /** @default null */
      mean?: unknown | null;
      /** @default null */
      median?: unknown | null;
      /** @default null */
      min?: unknown | null;
      /** @default null */
      nulls?: number | null;
      /** @default null */
      p25?: unknown | null;
      /** @default null */
      p5?: unknown | null;
      /** @default null */
      p75?: unknown | null;
      /** @default null */
      p95?: unknown | null;
      /** @default null */
      std?: unknown | null;
      /** @default null */
      total?: number | null;
      /** @default null */
      true?: number | null;
      /** @default null */
      unique?: number | null;
    };
    /**
     * CompletedRunNotification
     * @description The command's reactive cycle ended, after its console was flushed.
     */
    CompletedRunNotification: {
      /** @default null */
      error?: string | null;
      /** @enum {unknown} */
      op: "completed-run";
      /**
       * @default succeeded
       * @enum {unknown}
       */
      outcome?: "failed" | "interrupted" | "succeeded";
      /** @default null */
      run_id?: string | null;
    };
    /**
     * CompletionConfig
     * @description Configuration for code completion.
     *
     *         A dict with key/value pairs configuring code completion in the marimo
     *         editor.
     *
     *         **Keys.**
     *
     *         - `activate_on_typing`: if `False`, completion won't activate
     *         until the completion hotkey is entered
     *         - `signature_hint_on_typing`: if `False`, signature hint won't be shown when typing
     *         - `copilot`: one of `"github"`, `"codeium"`, or `"custom"`
     *         - `codeium_api_key`: the Codeium API key
     *         - `auto_close_pairs`: if `False`, typing an opening bracket, parenthesis,
     *         or quote will not automatically insert the closing character
     */
    CompletionConfig: {
      activate_on_typing: boolean;
      api_key?: string | null;
      auto_close_pairs?: boolean;
      base_url?: string | null;
      codeium_api_key?: string | null;
      copilot: boolean | ("codeium" | "custom" | "github");
      model?: string | null;
      signature_hint_on_typing: boolean;
    };
    /** CompletionOption */
    CompletionOption: {
      completion_info: string | null;
      name: string;
      type: string;
    };
    /**
     * CompletionResultNotification
     * @description Code completion result from language server.
     *
     *         Attributes:
     *             completion_id: Request ID this responds to.
     *             prefix_length: Length of prefix to replace.
     *             options: Completion options to display.
     */
    CompletionResultNotification: {
      completion_id: components["schemas"]["RequestId"];
      /** @enum {unknown} */
      op: "completion-result";
      options: components["schemas"]["CompletionOption"][];
      prefix_length: number;
    };
    /**
     * ConsumerCapabilities
     * @description Per-consumer access capabilities for a session connection.
     *
     *         - editor: `{edit: True, interact: True}`
     *         - interactor: `{edit: False, interact: True}` (default for a secondary
     *           connection: drives UI state but cannot edit the notebook)
     *         - read-only viewer: `{edit: False, interact: False}` (opt-in, set by a
     *           deployment's capability provider)
     *
     *         The server enforces these: control requests are gated against the issuing
     *         consumer's stored capabilities at the control-request chokepoint (the
     *         authority) and mirrored as an advisory HTTP 403 at the request handlers.
     *         Commands classified as `read` in `marimo._session.capabilities` (such as
     *         completions and previews) are always permitted.
     */
    ConsumerCapabilities: {
      edit: boolean;
      interact: boolean;
    };
    /**
     * ConsumerCapabilitiesNotification
     * @description Notification of the frontend consumer's capabilities.
     */
    ConsumerCapabilitiesNotification: {
      consumer_capabilities: components["schemas"]["ConsumerCapabilities"];
      /** @enum {unknown} */
      op: "consumer-capabilities";
    };
    /** CopyNotebookRequest */
    CopyNotebookRequest: {
      destination: string;
      source: string;
    };
    /**
     * CreateCell
     * @description Insert a new cell into the notebook.
     */
    CreateCell: {
      /** @default null */
      after?: components["schemas"]["CellId"] | null;
      /** @default null */
      before?: components["schemas"]["CellId"] | null;
      cellId: components["schemas"]["CellId"];
      code: string;
      config: components["schemas"]["CellConfig"];
      name: string;
      /** @enum {unknown} */
      type: "create-cell";
    };
    /** CreateSecretRequest */
    CreateSecretRequest: {
      key: string;
      name: string;
      /** @enum {unknown} */
      provider: "dotenv" | "env";
      value: string;
    };
    /** CycleError */
    CycleError: {
      edges_with_vars: [string, string[], string][];
      /** @enum {unknown} */
      type: "cycle";
    };
    /**
     * DataColumnPreviewNotification
     * @description Data column preview with stats and visualization.
     *
     *         Inherits all ColumnPreview attributes.
     *
     *         Attributes:
     *             table_name: Table containing the column.
     *             column_name: Column being previewed.
     */
    DataColumnPreviewNotification: {
      /** @default null */
      chart_code?: string | null;
      /** @default null */
      chart_spec?: string | null;
      column_name: string;
      /** @default null */
      error?: string | null;
      /** @default null */
      missing_packages?: string[] | null;
      /** @enum {unknown} */
      op: "data-column-preview";
      /** @default null */
      stats?: components["schemas"]["ColumnStats"] | null;
      table_name: string;
    };
    /**
     * DataSourceConnection
     * @description Represents a data source connection.
     *
     *     Attributes:
     *         source (str): The source of the data source connection. E.g 'postgres'.
     *         dialect (str): The dialect of the data source connection. E.g 'postgresql'.
     *         name (str): The name of the data source connection. E.g 'engine'.
     *         display_name (str): The display name of the data source connection. E.g 'PostgresQL (engine)'.
     *         databases (List[Database]): The databases in the data source connection.
     *         default_database (Optional[str]): The default database in the data source connection.
     *         default_schema (Optional[str]): The default schema in the data source connection.
     */
    DataSourceConnection: {
      databases: components["schemas"]["Database"][];
      /** @default null */
      default_database?: string | null;
      /** @default null */
      default_schema?: string | null;
      dialect: string;
      display_name: string;
      name: string;
      source: string;
    };
    /**
     * DataSourceConnectionsNotification
     * @description Available data source connections for SQL cells.
     *
     *         Attributes:
     *             connections: Available data source connections.
     */
    DataSourceConnectionsNotification: {
      connections: components["schemas"]["DataSourceConnection"][];
      /** @enum {unknown} */
      op: "data-source-connections";
    };
    /**
     * DataSourceDiscoveryResultNotification
     * @description High-confidence datasource connections discovered by the kernel.
     *
     *         Attributes:
     *             request_id: Request ID this responds to.
     *             sources: Detected datasource connection configurations.
     */
    DataSourceDiscoveryResultNotification: {
      /** @enum {unknown} */
      op: "data-source-discovery-result";
      request_id: components["schemas"]["RequestId"];
      sources: components["schemas"]["DetectedDataSource"][];
    };
    /**
     * DataTable
     * @description Represents a data table.
     *
     *     Attributes:
     *         source_type (DataTableSource): Type of data source ('local', 'duckdb', 'connection').
     *         source (str): Can be dialect, or source db name.
     *         name (str): Name of the data table.
     *         num_rows (Optional[int]): Total number of rows in the table, if known.
     *         num_columns (Optional[int]): Total number of columns in the table, if known.
     *         variable_name (Optional[VariableName]): Variable name referencing this table in code.
     *         columns (List[DataTableColumn]): List of column definitions and metadata.
     *         engine (Optional[VariableName]): Database engine or connection handler, if any.
     *         type (DataTableType): Table type, either 'table' or 'view'. Defaults to 'table'.
     *         primary_keys (Optional[List[str]]): Column names used as primary keys, if any.
     *         indexes (Optional[List[str]]): Column names used as indexes, if any.
     */
    DataTable: {
      columns: components["schemas"]["DataTableColumn"][];
      /** @default null */
      engine?: components["schemas"]["VariableName"] | null;
      /** @default null */
      indexes?: string[] | null;
      name: string;
      num_columns: number | null;
      num_rows: number | null;
      /** @default null */
      primary_keys?: string[] | null;
      source: string;
      /** @enum {unknown} */
      source_type: "catalog" | "connection" | "duckdb" | "local";
      /**
       * @default table
       * @enum {unknown}
       */
      type?: "table" | "view";
      variable_name: components["schemas"]["VariableName"] | null;
    };
    /**
     * DataTableColumn
     * @description Represents a column in a data table.
     *
     *     Attributes:
     *         name (str): The name of the column.
     *         type (DataType): The data type of the column.
     *         external_type (ExternalDataType): The raw data type of the column.
     *         sample_values (List[Any]): The sample values of the column.
     */
    DataTableColumn: {
      external_type: string;
      name: string;
      sample_values: unknown[];
      /** @enum {unknown} */
      type:
        | "boolean"
        | "date"
        | "datetime"
        | "geometry"
        | "integer"
        | "number"
        | "string"
        | "time"
        | "unknown";
    };
    /** @enum {unknown} */
    DataType:
      | "boolean"
      | "date"
      | "datetime"
      | "geometry"
      | "integer"
      | "number"
      | "string"
      | "time"
      | "unknown";
    /**
     * Database
     * @description Represents a collection of schemas.
     *
     *     Attributes:
     *         name (str): The name of the database
     *         dialect (str): The dialect of the database
     *         schemas (List[Schema]): List of schemas in the database.
     *         schemas_resolved (bool): True when `schemas` has been enumerated.
     *             False when schema discovery was deferred. Defaults to True
     *         engine (Optional[VariableName]): Database engine or connection handler, if any.
     */
    Database: {
      dialect: string;
      /** @default null */
      engine?: components["schemas"]["VariableName"] | null;
      name: string;
      schemas: components["schemas"]["Schema"][];
      /** @default true */
      schemas_resolved?: boolean;
    };
    /**
     * DatasetsNotification
     * @description Available datasets for data explorer.
     *
     *         Attributes:
     *             tables: Available data tables/datasets.
     *             clear_channel: If set, clears tables from this channel first.
     */
    DatasetsNotification: {
      /** @default null */
      clear_channel?: ("catalog" | "connection" | "duckdb" | "local") | null;
      /** @enum {unknown} */
      op: "datasets";
      tables: components["schemas"]["DataTable"][];
    };
    /**
     * DatasourcesConfig
     * @description Configuration for datasources panel.
     *
     *         **Keys.**
     *
     *         - `auto_discover_schemas`: if `True`, include schemas in the datasource
     *         - `auto_discover_tables`: if `True`, include tables in the datasource
     *         - `auto_discover_columns`: if `True`, include columns & table metadata in the datasource
     */
    DatasourcesConfig: {
      auto_discover_columns?: boolean | "auto";
      auto_discover_schemas?: boolean | "auto";
      auto_discover_tables?: boolean | "auto";
    };
    /** DebugCellRequest */
    DebugCellRequest: {
      cellId: components["schemas"]["CellId"];
      /** @default null */
      request?: components["schemas"]["HTTPRequest"] | null;
    };
    /**
     * DeleteCell
     * @description Remove a cell from the notebook.
     */
    DeleteCell: {
      cellId: components["schemas"]["CellId"];
      /** @enum {unknown} */
      type: "delete-cell";
    };
    /**
     * DeleteCellCommand
     * @description Delete a cell from the notebook.
     *
     *         Removes cell from the dependency graph and cleans up its variables.
     *         Dependent cells may become stale.
     *
     *         Attributes:
     *             cell_id: Cell to delete.
     */
    DeleteCellCommand: {
      cellId: components["schemas"]["CellId"];
      /** @enum {unknown} */
      type: "delete-cell";
    };
    /** DeleteSecretRequest */
    DeleteSecretRequest: {
      key: string;
    };
    /** DependencyTag */
    DependencyTag: {
      kind: string;
      value: string;
    };
    /** DependencyTreeNode */
    DependencyTreeNode: {
      dependencies: components["schemas"]["DependencyTreeNode"][];
      name: string;
      tags: components["schemas"]["DependencyTag"][];
      version: string | null;
    };
    /** DependencyTreeResponse */
    DependencyTreeResponse: {
      context:
        | components["schemas"]["SandboxPackageContext"]
        | components["schemas"]["PackageManagerContext"];
      tree: components["schemas"]["DependencyTreeNode"] | null;
    };
    /**
     * DetectedDataSource
     * @description A secret-free datasource suggestion produced by the kernel.
     */
    DetectedDataSource: {
      /** @enum {unknown} */
      category: "catalog" | "database" | "object-storage";
      code: string;
      /** @enum {unknown} */
      confidence: "high" | "medium";
      configuration: components["schemas"]["DetectedDataSourceConfiguration"][];
      displayName: string;
      hidesWhen:
        | components["schemas"]["DialectHidesWhen"]
        | components["schemas"]["StorageHidesWhen"];
      id: string;
      integration: string;
      origins: components["schemas"]["DetectedDataSourceOrigin"][];
    };
    /** DetectedDataSourceConfiguration */
    DetectedDataSourceConfiguration: {
      field: string;
      value:
        | components["schemas"]["EnvironmentVariableDiscoveryValue"]
        | components["schemas"]["SafeLiteralDiscoveryValue"];
    };
    /** DetectedDataSourceOrigin */
    DetectedDataSourceOrigin: {
      label: string;
      /** @enum {unknown} */
      type: "configuration" | "environment";
    };
    /**
     * DiagnosticsConfig
     * @description Configuration options for diagnostics.
     *
     *         **Keys.**
     *
     *         - `enabled`: if `True`, diagnostics will be shown in the editor
     *         - `sql_linter`: if `True`, SQL cells will have linting enabled
     */
    DiagnosticsConfig: {
      enabled?: boolean;
      sql_linter?: boolean;
    };
    /**
     * DialectHidesWhen
     * @description Hide this suggestion when a live SQL engine dialect contains a substring.
     */
    DialectHidesWhen: {
      /** @enum {unknown} */
      kind: "dialect";
      substrings: string[];
    };
    /**
     * DiscoverDataSourcesCommand
     * @description Discover datasource connections from the live kernel environment and configuration.
     *
     *         Attributes:
     *             request_id: Unique identifier for this request.
     */
    DiscoverDataSourcesCommand: {
      requestId: components["schemas"]["RequestId"];
      /** @enum {unknown} */
      type: "discover-data-sources";
    };
    /** DiscoverDataSourcesRequest */
    DiscoverDataSourcesRequest: {
      requestId: components["schemas"]["RequestId"];
    };
    /**
     * DisplayConfig
     * @description Configuration for display.
     *
     *         **Keys.**
     *
     *         - `theme`: `"light"`, `"dark"`, or `"system"`
     *         - `code_editor_font_size`: font size for the code editor
     *         - `cell_output`: `"above"` or `"below"`
     *         - `dataframes`: `"rich"` or `"plain"`
     *         - `custom_css`: list of paths to custom CSS files
     *         - `default_table_page_size`: default number of rows to display in tables
     *         - `default_table_max_columns`: default maximum number of columns to display in tables
     *         - `reference_highlighting`: if `True`, highlight reactive variable references
     *         - `code_lens`: if `True`, show inline icons in cell editors linking
     *           datasources, storage buckets, and caches to their panels
     *         - `locale`: locale for date formatting and internationalization (e.g., "en-US", "en-GB", "de-DE")
     */
    DisplayConfig: {
      /** @enum {unknown} */
      cell_output: "above" | "below";
      code_editor_font_size: number;
      code_lens?: boolean;
      custom_css?: string[];
      /** @enum {unknown} */
      dataframes: "plain" | "rich";
      default_table_max_columns: number;
      default_table_page_size: number;
      /** @enum {unknown} */
      default_width: "columns" | "compact" | "full" | "medium" | "normal";
      locale?: string | null;
      reference_highlighting?: boolean;
      /** @enum {unknown} */
      theme: "dark" | "light" | "system";
    };
    /**
     * EnvironmentOperation
     * @description Current progress and logs for one execution of environment work.
     */
    EnvironmentOperation: {
      /** @enum {unknown} */
      action: "install" | "prepare" | "remove" | "sync";
      logs: {
        [key: string]: string;
      };
      operation_id: string;
      packages: {
        [key: string]:
          | "failed"
          | "queued"
          | "restart-required"
          | "running"
          | "succeeded";
      };
      /** @enum {unknown} */
      source: "kernel" | "server";
      status:
        | components["schemas"]["OperationRunning"]
        | components["schemas"]["OperationSucceeded"]
        | components["schemas"]["OperationRestartRequired"]
        | components["schemas"]["OperationFailed"]
        | components["schemas"]["OperationCancelled"];
    };
    /**
     * EnvironmentOperationNotification
     * @description Current operation progress and changes to its named log streams.
     *
     *         Package statuses replace the previous map. Log chunks append to a stream,
     *         or replace it when `log_mode` is `replace`. The operation status determines
     *         completion independently of its packages and output streams.
     */
    EnvironmentOperationNotification: {
      /** @enum {unknown} */
      action: "install" | "prepare" | "remove" | "sync";
      /** @enum {unknown} */
      log_mode: "append" | "replace";
      logs: {
        [key: string]: string;
      };
      /** @enum {unknown} */
      op: "environment-operation";
      operation_id: string;
      packages: {
        [key: string]:
          | "failed"
          | "queued"
          | "restart-required"
          | "running"
          | "succeeded";
      };
      /** @enum {unknown} */
      source: "kernel" | "server";
      status:
        | components["schemas"]["OperationRunning"]
        | components["schemas"]["OperationSucceeded"]
        | components["schemas"]["OperationRestartRequired"]
        | components["schemas"]["OperationFailed"]
        | components["schemas"]["OperationCancelled"];
    };
    /**
     * EnvironmentState
     * @description Preparation, active operations, the latest mutation, and restarts.
     */
    EnvironmentState: {
      operations: components["schemas"]["EnvironmentOperation"][];
      restart_required: boolean;
    };
    /**
     * EnvironmentStateNotification
     * @description Replace the current state for one environment on connection.
     */
    EnvironmentStateNotification: {
      /** @enum {unknown} */
      op: "environment-state";
      /** @enum {unknown} */
      source: "kernel" | "server";
      state: components["schemas"]["EnvironmentState"];
    };
    /**
     * EnvironmentVariableDiscoveryValue
     * @description A reference to an environment variable, never its value.
     */
    EnvironmentVariableDiscoveryValue: {
      /** @enum {unknown} */
      kind: "environment-variable";
      name: string;
    };
    /**
     * EsmSpec
     * @description Where the frontend imports a widget's ESM from, and which version.
     *
     *         Specs travel only on kernel-authored notifications, never in model
     *         state: state is client-writable and echoed to peers, so executing
     *         code from it would let one client run code on another.
     *
     *         Attributes:
     *             url: URL to import the ESM from. A virtual file for inline
     *                 source; an external URL when `_esm` is itself a URL.
     *             hash: Hash of the `_esm` string. Keys the frontend module cache
     *                 and signals code changes (hot reload).
     */
    EsmSpec: {
      hash: string;
      url: string;
    };
    /**
     * ExecuteCellsCommand
     * @description Execute multiple cells in a batch.
     *
     *         Executes multiple cells with their corresponding code. The kernel manages
     *         dependency tracking and reactive execution.
     *
     *         Attributes:
     *             cell_ids: Cells to execute.
     *             codes: Python code for each cell. Must match length of cell_ids.
     *             request: HTTP request context if available.
     *             timestamp: Unix timestamp when command was created.
     *             run_id: Optional correlation ID. When set, the run's notifications
     *                 and its `CompletedRunNotification` carry it.
     *             allow_stdin: Whether cells may request interactive input.
     */
    ExecuteCellsCommand: {
      /** @default true */
      allowStdin?: boolean;
      cellIds: components["schemas"]["CellId"][];
      codes: string[];
      /** @default null */
      request?: components["schemas"]["HTTPRequest"] | null;
      /** @default null */
      runId?: string | null;
      timestamp?: number;
      /** @enum {unknown} */
      type: "execute-cells";
    };
    /** ExecuteCellsRequest */
    ExecuteCellsRequest: {
      cellIds: components["schemas"]["CellId"][];
      codes: string[];
      /** @default null */
      request?: components["schemas"]["HTTPRequest"] | null;
    };
    /**
     * ExecuteScratchpadCommand
     * @description Execute code in the scratchpad.
     *
     *         The scratchpad is a temporary execution environment that doesn't affect
     *         the notebook's cells or dependencies. Runs in an isolated cell with a copy
     *         of the global namespace, useful for experimentation.
     *
     *         Attributes:
     *             code: Python code to execute.
     *             request: HTTP request context if available.
     *             notebook_cells: Snapshot of notebook cells from the session document.
     *                 Used to populate the document ContextVar so code_mode can read
     *                 cell ordering, code, names, and configs.
     *             cell_outputs: Snapshot of per-cell outputs (main + console) from the
     *                 session view. Populates a parallel ContextVar so code_mode can
     *                 expose `cell.output` and `cell.console_outputs`. Frozen at
     *                 scratchpad start — not refreshed when `ctx.run_cell` produces
     *                 new outputs in the same batch.
     *             run_id: Optional correlation ID. When set, the
     *                 `CompletedRunNotification` emitted at the end of this command
     *                 carries the same `run_id` so a caller holding a
     *                 `ScratchCellListener` can filter for *its* completion and
     *                 ignore `CompletedRun` events from unrelated commands on the
     *                 same session.
     *             allow_stdin: Whether code may request interactive input. When false,
     *                 input reads receive EOF for the duration of this command.
     */
    ExecuteScratchpadCommand: {
      /** @default true */
      allowStdin?: boolean;
      /** @default null */
      cellOutputs?: components["schemas"]["CellOutputs"] | null;
      code: string;
      /** @default null */
      notebookCells?: components["schemas"]["NotebookCell"][] | null;
      /** @default null */
      request?: components["schemas"]["HTTPRequest"] | null;
      /** @default null */
      runId?: string | null;
      /** @enum {unknown} */
      type: "execute-scratchpad";
    };
    /** ExecuteScratchpadRequest */
    ExecuteScratchpadRequest: {
      /** @default true */
      allowStdin?: boolean;
      /** @default null */
      cellOutputs?: components["schemas"]["CellOutputs"] | null;
      code: string;
      /** @default null */
      notebookCells?: components["schemas"]["NotebookCell"][] | null;
      /** @default null */
      request?: components["schemas"]["HTTPRequest"] | null;
      /** @default null */
      runId?: string | null;
    };
    /**
     * ExecutionNotification
     * @description An attempt's lifecycle, independent of a cell's displayed status.
     *
     *         `planned` supplies the source and identity before output is reported.
     *         `running` means evaluation began. `completed` follows the final output
     *         and errors, including for attempts that never ran. Buffered and background
     *         console output may still arrive with the completed attempt's identity.
     */
    ExecutionNotification: {
      /** @default null */
      caused_by?: string | null;
      cell_id: components["schemas"]["CellId"];
      /** @default null */
      code?: string | null;
      /** @default null */
      depends_on?: {
        [key: string]: components["schemas"]["Revision"] | null;
      } | null;
      execution_id: string;
      /** @enum {unknown} */
      op: "execution";
      /** @enum {unknown} */
      phase: "completed" | "planned" | "running";
      run_id: string | null;
    };
    /**
     * ExportAsHTMLRequest
     * @description Request a static HTML export.
     *
     *         `layout` carries the current client layout. An omitted field reads the
     *         saved layout file, `null` selects the vertical layout, and an object uses
     *         that serialized layout for this export.
     */
    ExportAsHTMLRequest: {
      /** @default null */
      assetUrl?: string | null;
      download: boolean;
      files: string[];
      includeCode: boolean;
      layout?: components["schemas"]["LayoutConfig"] | null;
    };
    /** ExportAsIPYNBRequest */
    ExportAsIPYNBRequest: {
      download: boolean;
      /** @default true */
      includeOutputs?: boolean;
      /**
       * @default top-down
       * @enum {unknown}
       */
      sortMode?: "top-down" | "topological";
    };
    /** ExportAsMarkdownRequest */
    ExportAsMarkdownRequest: {
      download: boolean;
      /** @default null */
      flavor?: ("mdx" | "mystmd" | "pymdown" | "qmd") | null;
    };
    /** ExportAsPDFRequest */
    ExportAsPDFRequest: {
      /** @default false */
      includeInputs?: boolean;
      /** @default true */
      includeOutputs?: boolean;
      /**
       * @default document
       * @enum {unknown}
       */
      preset?: "document" | "slides";
      webpdf: boolean;
    };
    /** ExportAsScriptRequest */
    ExportAsScriptRequest: {
      download: boolean;
    };
    /** ExportAvailabilityResponse */
    ExportAvailabilityResponse: {
      formats: components["schemas"]["ExportFormatAvailability"][];
      /** @enum {unknown} */
      source: "server";
    };
    /** ExportFormatAvailability */
    ExportFormatAvailability: {
      dependenciesAvailable: boolean;
      /** @enum {unknown} */
      format: "html" | "ipynb" | "markdown" | "pdf" | "script";
      missingPackages: string[];
      missingSetup: components["schemas"]["ExportSetupRequirement"][];
    };
    /** ExportSetupRequirement */
    ExportSetupRequirement: {
      command: string;
      /** @enum {unknown} */
      name: "playwright-chromium";
    };
    /**
     * FileBrowserConfig
     * @description Configuration for the file browser panel.
     *
     *         **Keys.**
     *
     *         - `folders`: additional absolute folders to show in the file browser
     */
    FileBrowserConfig: {
      folders?: components["schemas"]["FolderConfig"][];
    };
    /** FileCopyRequest */
    FileCopyRequest: {
      newPath: string;
      path: string;
    };
    /** FileCopyResponse */
    FileCopyResponse: {
      /** @default null */
      info?: components["schemas"]["FileInfo"] | null;
      /** @default null */
      message?: string | null;
      success: boolean;
    };
    /**
     * FileCreateMultipartRequest
     * @description multipart/form-data body for POST /api/files/create.
     *
     *         Schema-only: this struct exists to describe the multipart shape in
     *         OpenAPI. At runtime, the endpoint reads the string fields from
     *         `MultipartRequest.body` and the uploaded bytes from
     *         `MultipartRequest.files["file"]` — `body.file` is never populated.
     */
    FileCreateMultipartRequest: {
      /**
       * Format: binary
       * @default null
       */
      file?: string | null;
      name: string;
      path: string;
      /** @enum {unknown} */
      type: "directory" | "file" | "notebook";
    };
    /** FileCreateRequest */
    FileCreateRequest: {
      /** @default null */
      contents?: string | null;
      name: string;
      path: string;
      /** @enum {unknown} */
      type: "directory" | "file" | "notebook";
    };
    /** FileCreateResponse */
    FileCreateResponse: {
      /** @default null */
      info?: components["schemas"]["FileInfo"] | null;
      /** @default null */
      message?: string | null;
      success: boolean;
    };
    /** FileDeleteRequest */
    FileDeleteRequest: {
      path: string;
    };
    /** FileDeleteResponse */
    FileDeleteResponse: {
      /** @default null */
      message?: string | null;
      success: boolean;
    };
    /** FileDetailsRequest */
    FileDetailsRequest: {
      /** @default null */
      maxBytes?: number | null;
      path: string;
    };
    /** FileDetailsResponse */
    FileDetailsResponse: {
      /** @default null */
      contents?: string | null;
      file: components["schemas"]["FileInfo"];
      /** @default false */
      isBase64?: boolean;
      /** @default false */
      isTooLarge?: boolean;
      /** @default null */
      mimeType?: string | null;
    };
    /** FileInfo */
    FileInfo: {
      /** @default [] */
      children?: components["schemas"]["FileInfo"][];
      id: string;
      isDirectory: boolean;
      isMarimoFile: boolean;
      /** @default null */
      lastModified?: number | null;
      name: string;
      /** @default null */
      opengraph?: components["schemas"]["OpenGraphMetadata"] | null;
      path: string;
      /** @default null */
      size?: number | null;
    };
    /** FileListRequest */
    FileListRequest: {
      /** @default null */
      path?: string | null;
    };
    /** FileListResponse */
    FileListResponse: {
      files: components["schemas"]["FileInfo"][];
      root: string;
    };
    /** FileMoveRequest */
    FileMoveRequest: {
      newPath: string;
      path: string;
    };
    /** FileMoveResponse */
    FileMoveResponse: {
      /** @default null */
      info?: components["schemas"]["FileInfo"] | null;
      /** @default null */
      message?: string | null;
      success: boolean;
    };
    /** FileOpenRequest */
    FileOpenRequest: {
      /** @default null */
      lineNumber?: number | null;
      path: string;
    };
    /** FileRoot */
    FileRoot: {
      isPrimary: boolean;
      name: string;
      path: string;
    };
    /** FileRootsResponse */
    FileRootsResponse: {
      roots: components["schemas"]["FileRoot"][];
    };
    /** FileSearchRequest */
    FileSearchRequest: {
      /** @default 3 */
      depth?: number;
      /** @default true */
      includeDirectories?: boolean;
      /** @default true */
      includeFiles?: boolean;
      /** @default true */
      includeHidden?: boolean;
      /** @default 100 */
      limit?: number;
      /** @default null */
      path?: string | null;
      query: string;
    };
    /** FileSearchResponse */
    FileSearchResponse: {
      files: components["schemas"]["FileInfo"][];
      query: string;
      totalFound: number;
    };
    /** FileUpdateRequest */
    FileUpdateRequest: {
      contents: string;
      path: string;
    };
    /** FileUpdateResponse */
    FileUpdateResponse: {
      /** @default null */
      info?: components["schemas"]["FileInfo"] | null;
      /** @default null */
      message?: string | null;
      success: boolean;
    };
    /**
     * FocusCellNotification
     * @description Focuses a cell (kiosk mode).
     *
     *         Attributes:
     *             cell_id: Cell to focus.
     */
    FocusCellNotification: {
      cell_id: components["schemas"]["CellId"];
      /** @enum {unknown} */
      op: "focus-cell";
    };
    /** FocusCellRequest */
    FocusCellRequest: {
      cellId: components["schemas"]["CellId"];
    };
    /**
     * FolderConfig
     * @description Configuration for an additional file browser root.
     *
     *         **Keys.**
     *
     *         - `path`: the absolute path to the folder
     *         - `name`: an optional display name for the folder
     */
    FolderConfig: {
      name?: string;
      path: string;
    };
    /** FormatCellsRequest */
    FormatCellsRequest: {
      codes: {
        [key: string]: string;
      };
      lineLength: number;
    };
    /** FormatResponse */
    FormatResponse: {
      codes: {
        [key: string]: string;
      };
    };
    /**
     * FormattingConfig
     * @description Configuration for code formatting.
     *
     *         **Keys.**
     *
     *         - `line_length`: max line length
     */
    FormattingConfig: {
      /** @enum {unknown} */
      infer_types?: "jedi" | "off";
      line_length: number;
    };
    /**
     * FunctionCallResultNotification
     * @description Result of a frontend-initiated function call.
     *
     *         Attributes:
     *             function_call_id: ID matching the original request.
     *             return_value: Function return value as JSON.
     *             status: Human-readable success/failure status.
     *             found: Whether the requested function was located in the registry.
     *                 False signals a transient registry desync, so the request is safe
     *                 to retry. True means no retry will help: a non-ok status then
     *                 reflects a failure unrelated to lookup, such as the function
     *                 raising during execution or not being associated with a cell.
     */
    FunctionCallResultNotification: {
      found: boolean;
      function_call_id: components["schemas"]["RequestId"];
      /** @enum {unknown} */
      op: "function-call-result";
      return_value: unknown;
      status: components["schemas"]["HumanReadableStatus"];
    };
    /** GetCacheInfoRequest */
    GetCacheInfoRequest: Record<string, any>;
    /**
     * GitHubConfig
     * @description Configuration options for GitHub Copilot.
     *
     *         **Keys.**
     *
     *         - `api_key`: a GitHub Copilot token or an `env:` reference
     *         - `base_url`: the base URL for the GitHub Copilot API
     *         - `copilot_settings`: configuration settings for GitHub Copilot LSP.
     *             Supports settings like `http` (proxy configuration), `telemetry`,
     *             and `github-enterprise` (enterprise URI).
     */
    GitHubConfig: {
      api_key?: string;
      base_url?: string;
      copilot_settings?: Record<string, any>;
    };
    /**
     * GoogleAiConfig
     * @description Configuration options for Google AI.
     *
     *         **Keys.**
     *
     *         - `api_key`: the Google AI API key or an `env:` reference
     */
    GoogleAiConfig: {
      api_key?: string;
    };
    /**
     * HTTPRequest
     * @description Serializable HTTP request representation.
     *
     *         Mimics Starlette/FastAPI Request but is pickle-able and contains only a safe
     *         subset of data. Excludes session and auth to prevent exposing sensitive data.
     *
     *         Attributes:
     *             url: Serialized URL with path, port, scheme, netloc, query, hostname.
     *             base_url: Serialized base URL.
     *             headers: Request headers (marimo-specific headers excluded).
     *             query_params: Query parameters mapped to lists of values.
     *             path_params: Path parameters from the URL route.
     *             cookies: Request cookies.
     *             meta: User-defined storage for custom data.
     *             user: User info from authentication middleware (e.g., is_authenticated, username).
     */
    HTTPRequest: {
      base_url: Record<string, any>;
      cookies: {
        [key: string]: string;
      };
      headers: {
        [key: string]: string;
      };
      meta: Record<string, any>;
      path_params: Record<string, any>;
      query_params: {
        [key: string]: string[];
      };
      url: Record<string, any>;
      user: unknown;
    };
    /**
     * HumanReadableStatus
     * @description Human-readable status for operation results.
     *
     *         Attributes:
     *             code: Status code ("ok" or "error").
     *             title: Optional short title.
     *             message: Optional detailed description.
     */
    HumanReadableStatus: {
      /** @enum {unknown} */
      code: "error" | "ok";
      /** @default null */
      message?: string | null;
      /** @default null */
      title?: string | null;
    };
    /** ImportStarError */
    ImportStarError: {
      /** @default null */
      lineno?: number | null;
      msg: string;
      /** @enum {unknown} */
      type: "import-star";
    };
    /** InstallExportRequirementsRequest */
    InstallExportRequirementsRequest: {
      /** @enum {unknown} */
      format: "html" | "ipynb" | "markdown" | "pdf" | "script";
    };
    /**
     * InstallPackagesCommand
     * @description Install Python packages.
     *
     *         Installs missing packages using the specified package manager. Triggered
     *         automatically on import errors or manually by the user.
     *
     *         Attributes:
     *             manager: Package manager to use ('pip', 'conda', 'uv', etc.).
     *             versions: Package names mapped to version specifiers. Empty version
     *                       means install latest.
     *             index_urls: Alternative package index URLs. Primary index first,
     *                         then extras. Honored by backends that support custom
     *                         indexes (currently micropip); other backends ignore it.
     *             source: Where to install. "kernel" (default) dispatches to the kernel
     *                     subprocess; "server" installs directly into the server's Python
     *                     environment (sys.executable), used when the server itself needs
     *                     a package (e.g. nbformat for IPYNB auto-export in sandbox mode).
     */
    InstallPackagesCommand: {
      /** @default [] */
      indexUrls?: string[];
      manager: string;
      /**
       * @default kernel
       * @enum {unknown}
       */
      source?: "kernel" | "server";
      /** @enum {unknown} */
      type: "install-packages";
      versions: {
        [key: string]: string;
      };
    };
    /** InstallPackagesRequest */
    InstallPackagesRequest: {
      /** @default [] */
      indexUrls?: string[];
      manager: string;
      /**
       * @default kernel
       * @enum {unknown}
       */
      source?: "kernel" | "server";
      versions: {
        [key: string]: string;
      };
    };
    /** InstantiateNotebookRequest */
    InstantiateNotebookRequest: {
      /** @default true */
      autoRun?: boolean;
      /** @default null */
      codes?: {
        [key: string]: string;
      } | null;
      objectIds: components["schemas"]["UIElementId"][];
      values: unknown[];
    };
    /**
     * InterruptedNotification
     * @description Kernel was interrupted by user (SIGINT/Ctrl+C).
     */
    InterruptedNotification: {
      /** @enum {unknown} */
      op: "interrupted";
      run_id?: string | null;
    };
    /** InvokeAiToolRequest */
    InvokeAiToolRequest: {
      arguments: Record<string, any>;
      toolName: string;
    };
    /** InvokeAiToolResponse */
    InvokeAiToolResponse: {
      /** @default null */
      error?: string | null;
      result: unknown;
      success: boolean;
      toolName: string;
    };
    /**
     * InvokeFunctionCommand
     * @description Invoke a function from a UI element.
     *
     *         Called when a UI element needs to invoke a Python function.
     *
     *         Attributes:
     *             function_call_id: Unique identifier for this call.
     *             namespace: Namespace where the function is registered.
     *             function_name: Function to invoke.
     *             args: Keyword arguments for the function.
     */
    InvokeFunctionCommand: {
      args: Record<string, any>;
      functionCallId: components["schemas"]["RequestId"];
      functionName: string;
      namespace: string;
      /** @enum {unknown} */
      type: "invoke-function";
    };
    /** InvokeFunctionRequest */
    InvokeFunctionRequest: {
      args: Record<string, any>;
      functionCallId: components["schemas"]["RequestId"];
      functionName: string;
      namespace: string;
    };
    /**
     * KernelCapabilitiesNotification
     * @description Kernel capabilities detected at startup.
     *
     *         All fields auto-detected in __post_init__.
     *
     *         Attributes:
     *             terminal: Terminal access (unavailable on Windows/Pyodide).
     *             pylsp: Python Language Server Protocol installed.
     *             ty: ty type checker installed.
     *             basedpyright: basedpyright type checker installed.
     */
    KernelCapabilitiesNotification: {
      /** @default false */
      basedpyright?: boolean;
      /** @default false */
      pylsp?: boolean;
      /** @default false */
      pyrefly?: boolean;
      /** @default false */
      terminal?: boolean;
      /** @default false */
      ty?: boolean;
    };
    /**
     * KernelReadyNotification
     * @description Kernel ready for execution. First notification sent at startup.
     *
     *         Attributes:
     *             layout: Notebook layout config.
     *             resumed: Whether resumed from previous session.
     *             ui_values: Previous UI element values if resumed.
     *             last_executed_code: Last executed code per cell if resumed.
     *             last_execution_time: Last execution time per cell if resumed.
     *             app_config: Application configuration.
     *             kiosk: Whether running in kiosk mode.
     *             capabilities: Available kernel capabilities.
     *             auto_instantiated: Whether cells already executed (run mode).
     *             stable_session_id: Server-owned Session identity that survives
     *                 browser reconnects. None where no server Session exists.
     */
    KernelReadyNotification: {
      app_config: components["schemas"]["_AppConfig"];
      /** @default false */
      auto_instantiated?: boolean;
      capabilities: components["schemas"]["KernelCapabilitiesNotification"];
      consumer_capabilities: components["schemas"]["ConsumerCapabilities"];
      kiosk: boolean;
      last_executed_code: {
        [key: string]: string;
      } | null;
      last_execution_time: {
        [key: string]: number;
      } | null;
      layout: components["schemas"]["LayoutConfig"] | null;
      /** @enum {unknown} */
      op: "kernel-ready";
      resumed: boolean;
      /** @default null */
      stable_session_id?: string | null;
      ui_values: Record<string, any> | null;
    };
    /**
     * KernelStartupErrorNotification
     * @description Kernel failed to start.
     *
     *         Attributes:
     *             error: Error message describing failure.
     */
    KernelStartupErrorNotification: {
      error: string;
      /** @enum {unknown} */
      op: "kernel-startup-error";
    };
    /** KernelStatusResponse */
    KernelStatusResponse: {
      /** @enum {unknown} */
      state: "idle" | "running" | "stopped";
    };
    /**
     * KeymapConfig
     * @description Configuration for keymaps.
     *
     *         **Keys.**
     *
     *         - `preset`: one of `"default"` or `"vim"`
     *         - `overrides`: a dict of keymap actions to their keymap override
     *         - `vimrc`: path to a vimrc file to load keymaps from
     *         - `destructive_delete`: if `True`, allows deleting cells with content.
     */
    KeymapConfig: {
      destructive_delete?: boolean;
      overrides?: {
        [key: string]: string;
      };
      /** @enum {unknown} */
      preset: "default" | "vim";
      vimrc?: string | null;
    };
    /**
     * KnownUnions
     * @deprecated
     * @description Use the named NotificationMessage, ClientCommand, MarimoError, and DataType schemas directly.
     */
    KnownUnions: {
      command: components["schemas"]["ClientCommand"];
      data_type: components["schemas"]["DataType"];
      error: components["schemas"]["MarimoError"];
      notification: components["schemas"]["NotificationMessage"];
    };
    /**
     * LanguageServersConfig
     * @description Configuration options for language servers.
     *
     *         **Keys.**
     *
     *         - `pylsp`: the pylsp config
     *         - `basedpyright`: the basedpyright config
     *         - `ty`: the ty config
     *         - `pyrefly`: the pyrefly config
     */
    LanguageServersConfig: {
      basedpyright?: components["schemas"]["BasedpyrightServerConfig"];
      pylsp?: components["schemas"]["PythonLanguageServerConfig"];
      pyrefly?: components["schemas"]["PyreflyLanguageServerConfig"];
      ty?: components["schemas"]["TyLanguageServerConfig"];
    };
    /** LayoutConfig */
    LayoutConfig: {
      data: Record<string, any>;
      type: string;
    };
    /** LazyImportError */
    LazyImportError: {
      /** @default null */
      lineno?: number | null;
      msg: string;
      /** @enum {unknown} */
      type: "lazy-import";
    };
    /**
     * LintConfig
     * @description Configuration for lint rule selection.
     *
     *         Follows ruff-inspired semantics for selecting which rules to run
     *         during `marimo check`.
     *
     *         **Keys.**
     *
     *         - `select`: list of rule code prefixes that replaces the default
     *           enabled set. Use `"ALL"` to select all rules.
     *           Example: `["MB", "MR001"]`
     *         - `ignore`: list of rule code prefixes to remove from the
     *           enabled set.
     */
    LintConfig: {
      ignore?: string[];
      select?: string[];
    };
    /**
     * ListDataSourceConnectionCommand
     * @description List data source schemas.
     *
     *         Retrieves available schemas for a data source engine.
     *
     *         Attributes:
     *             engine: Data source engine identifier.
     */
    ListDataSourceConnectionCommand: {
      engine: string;
      /** @enum {unknown} */
      type: "list-data-source-connection";
    };
    /** ListDataSourceConnectionRequest */
    ListDataSourceConnectionRequest: {
      engine: string;
    };
    /** ListPackagesResponse */
    ListPackagesResponse: {
      packages: components["schemas"]["PackageDescription"][];
    };
    /**
     * ListSQLSchemasCommand
     * @description List schemas in an SQL database.
     *
     *         Retrieves names of all schemas in a database. Used by the SQL editor for
     *         schema selection.
     *
     *         Attributes:
     *             request_id: Unique identifier for this request.
     *             engine: SQL engine ('postgresql', 'mysql', 'duckdb', etc.).
     *             database: Database to query.
     *             schema_path: Parent schema path whose child schemas to list.
     *                 Empty lists the database's top-level schemas.
     */
    ListSQLSchemasCommand: {
      database: string;
      engine: string;
      requestId: components["schemas"]["RequestId"];
      /** @default [] */
      schemaPath?: string[];
      /** @enum {unknown} */
      type: "list-sql-schemas";
    };
    /** ListSQLSchemasRequest */
    ListSQLSchemasRequest: {
      database: string;
      engine: string;
      requestId: components["schemas"]["RequestId"];
      /** @default [] */
      schemaPath?: string[];
    };
    /**
     * ListSQLTablesCommand
     * @description List tables in an SQL schema.
     *
     *         Retrieves names of all tables and views in a schema. Used by the SQL
     *         editor for table selection.
     *
     *         Attributes:
     *             request_id: Unique identifier for this request.
     *             engine: SQL engine ('postgresql', 'mysql', 'duckdb', etc.).
     *             database: Database to query.
     *             schema: Schema to list tables from.
     *             schema_path: Path of nested schemas (relative to `database`) for
     *                 catalogs with nested schemas. Empty for the top level.
     */
    ListSQLTablesCommand: {
      database: string;
      engine: string;
      requestId: components["schemas"]["RequestId"];
      schema: string;
      /** @default [] */
      schemaPath?: string[];
      /** @enum {unknown} */
      type: "list-sql-tables";
    };
    /** ListSQLTablesRequest */
    ListSQLTablesRequest: {
      database: string;
      engine: string;
      requestId: components["schemas"]["RequestId"];
      schema: string;
      /** @default [] */
      schemaPath?: string[];
    };
    /**
     * ListSecretKeysCommand
     * @description List available secret keys.
     *
     *         Retrieves secret names without exposing values.
     *
     *         Attributes:
     *             request_id: Unique identifier for this request.
     */
    ListSecretKeysCommand: {
      requestId: components["schemas"]["RequestId"];
      /** @enum {unknown} */
      type: "list-secret-keys";
    };
    /** ListSecretKeysRequest */
    ListSecretKeysRequest: {
      requestId: components["schemas"]["RequestId"];
    };
    /** ListSecretKeysResponse */
    ListSecretKeysResponse: {
      keys: components["schemas"]["SecretKeysWithProvider"][];
    };
    /**
     * LspHealthResponse
     * @description Aggregated health response for all LSP servers.
     */
    LspHealthResponse: {
      servers: components["schemas"]["LspServerHealth"][];
      /** @enum {unknown} */
      status: "degraded" | "healthy" | "unhealthy";
    };
    /**
     * LspRestartRequest
     * @description Request to restart LSP servers.
     */
    LspRestartRequest: {
      /** @default null */
      serverIds?: string[] | null;
    };
    /**
     * LspRestartResponse
     * @description Response from restart operation.
     */
    LspRestartResponse: {
      /** @default {} */
      errors?: {
        [key: string]: string;
      };
      restarted: string[];
      success: boolean;
    };
    /**
     * LspServerHealth
     * @description Health status for a single LSP server.
     *
     *         Status meanings:
     *         - starting: process launched, initializing
     *         - running: healthy and responsive to pings
     *         - stopped: not running (never started or cleanly stopped)
     *         - crashed: exited with non-zero code
     *         - unresponsive: process alive but not responding to pings
     */
    LspServerHealth: {
      /** @default null */
      error?: string | null;
      /** @default null */
      lastPingMs?: number | null;
      port: number;
      serverId: string;
      /** @default null */
      startedAt?: number | null;
      /** @enum {unknown} */
      status: "crashed" | "running" | "starting" | "stopped" | "unresponsive";
    };
    /**
     * MCPConfig
     * @description Configuration for MCP servers
     *
     *     Note: the field name `mcpServers` is camelCased to match MCP server
     *     config conventions used by popular AI applications (e.g. Cursor, Claude Desktop, etc.)
     */
    MCPConfig: {
      mcpServers: {
        [key: string]: Record<string, any>;
      };
      presets?: ("context7" | "marimo")[];
    };
    /** MCPRefreshResponse */
    MCPRefreshResponse: {
      /** @default null */
      error?: string | null;
      /** @default {} */
      servers?: {
        [key: string]: boolean;
      };
      success: boolean;
    };
    /** MCPStatusResponse */
    MCPStatusResponse: {
      /** @default null */
      error?: string | null;
      /** @default {} */
      servers?: {
        [key: string]: "connected" | "disconnected" | "failed" | "pending";
      };
      /** @enum {unknown} */
      status: "error" | "ok" | "partial";
    };
    /** MarimoAncestorPreventedError */
    MarimoAncestorPreventedError: {
      blamed_cell: components["schemas"]["CellId"] | null;
      msg: string;
      raising_cell: components["schemas"]["CellId"];
      /** @enum {unknown} */
      type: "ancestor-prevented";
    };
    /** MarimoAncestorStoppedError */
    MarimoAncestorStoppedError: {
      msg: string;
      raising_cell: components["schemas"]["CellId"];
      /** @enum {unknown} */
      type: "ancestor-stopped";
    };
    /**
     * MarimoConfig
     * @description Configuration for the marimo editor
     */
    MarimoConfig: {
      ai?: components["schemas"]["AiConfig"];
      cache?: components["schemas"]["CacheConfig"];
      completion: components["schemas"]["CompletionConfig"];
      datasources?: components["schemas"]["DatasourcesConfig"];
      diagnostics?: components["schemas"]["DiagnosticsConfig"];
      display: components["schemas"]["DisplayConfig"];
      experimental?: Record<string, any>;
      file_browser?: components["schemas"]["FileBrowserConfig"];
      formatting: components["schemas"]["FormattingConfig"];
      keymap: components["schemas"]["KeymapConfig"];
      language_servers?: components["schemas"]["LanguageServersConfig"];
      lint?: components["schemas"]["LintConfig"];
      mcp?: components["schemas"]["MCPConfig"];
      package_management: components["schemas"]["PackageManagementConfig"];
      runtime: components["schemas"]["RuntimeConfig"];
      save: components["schemas"]["SaveConfig"];
      server: components["schemas"]["ServerConfig"];
      sharing?: components["schemas"]["SharingConfig"];
      signing?: components["schemas"]["SigningConfig"];
      snippets?: components["schemas"]["SnippetsConfig"];
      venv?: components["schemas"]["VenvConfig"];
    };
    MarimoError:
      | components["schemas"]["SetupRootError"]
      | components["schemas"]["CycleError"]
      | components["schemas"]["MultipleDefinitionError"]
      | components["schemas"]["ImportStarError"]
      | components["schemas"]["LazyImportError"]
      | components["schemas"]["MarimoAncestorStoppedError"]
      | components["schemas"]["MarimoAncestorPreventedError"]
      | components["schemas"]["MarimoExceptionRaisedError"]
      | components["schemas"]["MarimoStrictExecutionError"]
      | components["schemas"]["MarimoInterruptionError"]
      | components["schemas"]["MarimoSyntaxError"]
      | components["schemas"]["MarimoInternalError"]
      | components["schemas"]["MarimoSQLError"]
      | components["schemas"]["UnknownError"];
    /** MarimoExceptionRaisedError */
    MarimoExceptionRaisedError: {
      exception_type: string;
      msg: string;
      raising_cell: components["schemas"]["CellId"] | null;
      /** @default null */
      traceback?: string | null;
      /** @enum {unknown} */
      type: "exception";
    };
    /** MarimoFile */
    MarimoFile: {
      /** @default null */
      initializationId?: string | null;
      /** @default null */
      lastModified?: number | null;
      name: string;
      path: string;
      /** @default null */
      sessionId?: components["schemas"]["SessionId"] | null;
    };
    /**
     * MarimoInternalError
     * @description An internal error that should be hidden from the user.
     *     The error is logged to the console and then a new error is broadcasted
     *     such that the data is hidden.
     *
     *     They can be linked back to the original error by the error_id.
     */
    MarimoInternalError: {
      error_id: string;
      /** @default  */
      msg?: string;
      /** @enum {unknown} */
      type: "internal";
    };
    /** MarimoInterruptionError */
    MarimoInterruptionError: {
      /** @enum {unknown} */
      type: "interruption";
    };
    /**
     * MarimoSQLError
     * @description SQL-specific error with enhanced metadata for debugging.
     */
    MarimoSQLError: {
      /** @default null */
      hint?: string | null;
      msg: string;
      /** @default 0 */
      node_col_offset?: number;
      /** @default 0 */
      node_lineno?: number;
      /** @default null */
      sql_col?: number | null;
      /** @default null */
      sql_line?: number | null;
      sql_statement: string;
      /** @enum {unknown} */
      type: "sql-error";
    };
    /** MarimoStrictExecutionError */
    MarimoStrictExecutionError: {
      blamed_cell: components["schemas"]["CellId"] | null;
      msg: string;
      ref: string;
      /** @enum {unknown} */
      type: "strict-exception";
    };
    /** MarimoSyntaxError */
    MarimoSyntaxError: {
      /** @default null */
      lineno?: number | null;
      msg: string;
      /** @enum {unknown} */
      type: "syntax";
    };
    /**
     * MissingPackageAlertNotification
     * @description Alert for missing packages with install option.
     *
     *         Attributes:
     *             packages: Missing package names.
     *             isolated: Whether auto-install is possible in this environment.
     *             source: Which Python environment to install into. "kernel" (default)
     *                     installs in the kernel's venv; "server" installs in the
     *                     server's own Python env (e.g. for formatter tools like ruff).
     */
    MissingPackageAlertNotification: {
      isolated: boolean;
      /** @enum {unknown} */
      op: "missing-package-alert";
      packages: string[];
      /**
       * @default kernel
       * @enum {unknown}
       */
      source?: "kernel" | "server";
    };
    /**
     * ModelClose
     * @description Widget destruction.
     */
    ModelClose: {
      /** @enum {unknown} */
      method: "close";
    };
    /**
     * ModelCommand
     * @description Widget model message command.
     *
     *         Handles widget model communication between frontend and backend.
     *
     *         Attributes:
     *             model_id: Widget model identifier.
     *             message: Model message (update or custom).
     *             buffers: Base64-encoded binary buffers.
     *             token: Unique identifier for deduplication across dual queues.
     */
    ModelCommand: {
      buffers: components["schemas"]["Base64String"][];
      message:
        | components["schemas"]["ModelUpdateMessage"]
        | components["schemas"]["ModelCustomMessage"];
      modelId: components["schemas"]["WidgetModelId"];
      token?: string;
      /** @enum {unknown} */
      type: "model";
    };
    /**
     * ModelCustom
     * @description Custom application message.
     */
    ModelCustom: {
      buffers: components["schemas"]["Base64String"][];
      content: unknown;
      /** @enum {unknown} */
      method: "custom";
    };
    /**
     * ModelCustomMessage
     * @description Custom widget message.
     *
     *         Attributes:
     *             content: Arbitrary content for the custom message.
     */
    ModelCustomMessage: {
      content: unknown;
      /** @enum {unknown} */
      method: "custom";
    };
    /**
     * ModelLifecycleNotification
     * @description Widget model lifecycle message.
     *
     *         Mirrors the Jupyter widget comm protocol with open/update/custom/close.
     *
     *         Attributes:
     *             model_id: Widget model identifier.
     *             message: The lifecycle message (open/update/custom/close).
     */
    ModelLifecycleNotification: {
      message:
        | components["schemas"]["ModelOpen"]
        | components["schemas"]["ModelUpdate"]
        | components["schemas"]["ModelCustom"]
        | components["schemas"]["ModelClose"];
      model_id: components["schemas"]["WidgetModelId"];
      /** @enum {unknown} */
      op: "model-lifecycle";
    };
    /**
     * ModelOpen
     * @description Initial widget state on creation.
     *
     *         For anywidgets, the widget's ESM does not travel in `state`: the
     *         comm strips `_esm` and sends an `EsmSpec` instead. `None` for
     *         models with no ESM (e.g. traditional ipywidgets).
     *
     *         Attributes:
     *             state: Initial trait values, minus `_esm`.
     *             buffer_paths: Paths into `state` whose binary values were
     *                 extracted into `buffers`.
     *             buffers: Binary payloads, parallel to `buffer_paths`.
     *             esm_spec: Where to import this widget's ESM from.
     */
    ModelOpen: {
      buffer_paths: (string | number)[][];
      buffers: components["schemas"]["Base64String"][];
      /** @default null */
      esm_spec?: components["schemas"]["EsmSpec"] | null;
      /** @enum {unknown} */
      method: "open";
      state: Record<string, any>;
    };
    /** ModelRequest */
    ModelRequest: {
      buffers: components["schemas"]["Base64String"][];
      message:
        | components["schemas"]["ModelUpdateMessage"]
        | components["schemas"]["ModelCustomMessage"];
      modelId: components["schemas"]["WidgetModelId"];
      token?: string;
    };
    /**
     * ModelUpdate
     * @description State sync - changed traits only.
     *
     *         Attributes:
     *             state: Changed trait values, minus `_esm` (see `ModelOpen`).
     *             buffer_paths: Paths into `state` whose binary values were
     *                 extracted into `buffers`.
     *             buffers: Binary payloads, parallel to `buffer_paths`.
     *             esm_spec: Present only when the widget's `_esm` changed on a
     *                 live model (hot reload, edit mode only). A spec whose
     *                 `hash` differs from the current one tells the frontend the
     *                 widget's code changed and views must be rebuilt.
     */
    ModelUpdate: {
      buffer_paths: (string | number)[][];
      buffers: components["schemas"]["Base64String"][];
      /** @default null */
      esm_spec?: components["schemas"]["EsmSpec"] | null;
      /** @enum {unknown} */
      method: "update";
      state: Record<string, any>;
    };
    /**
     * ModelUpdateMessage
     * @description Widget model state update message.
     *
     *         Attributes:
     *             state: Model state updates.
     *             buffer_paths: Paths within state dict pointing to binary buffers.
     */
    ModelUpdateMessage: {
      bufferPaths: (string | number)[][];
      /** @enum {unknown} */
      method: "update";
      state: Record<string, any>;
    };
    /**
     * MoveCell
     * @description Reposition a cell in the notebook.
     */
    MoveCell: {
      /** @default null */
      after?: components["schemas"]["CellId"] | null;
      /** @default null */
      before?: components["schemas"]["CellId"] | null;
      cellId: components["schemas"]["CellId"];
      /** @enum {unknown} */
      type: "move-cell";
    };
    /** MultipleDefinitionError */
    MultipleDefinitionError: {
      cells: components["schemas"]["CellId"][];
      name: string;
      /** @enum {unknown} */
      type: "multiple-defs";
    };
    /**
     * NotebookCell
     * @description A single cell in the document. Mutable — owned by the document.
     *
     *         `version` increments on each `SetCode` that actually changes
     *         `code`. Other property changes don't bump it.
     */
    NotebookCell: {
      code: string;
      config: components["schemas"]["CellConfig"];
      id: components["schemas"]["CellId"];
      name: string;
      /** @default 0 */
      version?: number;
    };
    /**
     * NotebookDocumentTransactionNotification
     * @description Broadcasts an applied transaction to the frontend.
     *
     *         Sent by the session when the document changes (from any source).
     *         The frontend applies the ops to update its local state.
     */
    NotebookDocumentTransactionNotification: {
      /** @enum {unknown} */
      op: "notebook-document-transaction";
      transaction: components["schemas"]["Transaction"];
    };
    NotificationMessage:
      | components["schemas"]["CellNotification"]
      | components["schemas"]["ExecutionNotification"]
      | components["schemas"]["FunctionCallResultNotification"]
      | components["schemas"]["UIElementMessageNotification"]
      | components["schemas"]["ModelLifecycleNotification"]
      | components["schemas"]["RemoveUIElementsNotification"]
      | components["schemas"]["ReloadNotification"]
      | components["schemas"]["ReconnectedNotification"]
      | components["schemas"]["InterruptedNotification"]
      | components["schemas"]["CompletedRunNotification"]
      | components["schemas"]["KernelReadyNotification"]
      | components["schemas"]["CompletionResultNotification"]
      | components["schemas"]["AlertNotification"]
      | components["schemas"]["BannerNotification"]
      | components["schemas"]["MissingPackageAlertNotification"]
      | components["schemas"]["EnvironmentOperationNotification"]
      | components["schemas"]["EnvironmentStateNotification"]
      | components["schemas"]["StartupLogsNotification"]
      | components["schemas"]["StartupProgressNotification"]
      | components["schemas"]["KernelStartupErrorNotification"]
      | components["schemas"]["VariablesNotification"]
      | components["schemas"]["VariableValuesNotification"]
      | components["schemas"]["QueryParamsSetNotification"]
      | components["schemas"]["QueryParamsAppendNotification"]
      | components["schemas"]["QueryParamsDeleteNotification"]
      | components["schemas"]["QueryParamsClearNotification"]
      | components["schemas"]["DatasetsNotification"]
      | components["schemas"]["DataColumnPreviewNotification"]
      | components["schemas"]["SQLTablePreviewNotification"]
      | components["schemas"]["SQLTableListPreviewNotification"]
      | components["schemas"]["SQLSchemaListPreviewNotification"]
      | components["schemas"]["DataSourceConnectionsNotification"]
      | components["schemas"]["DataSourceDiscoveryResultNotification"]
      | components["schemas"]["ValidateSQLResultNotification"]
      | components["schemas"]["StorageNamespacesNotification"]
      | components["schemas"]["StorageEntriesNotification"]
      | components["schemas"]["StorageDownloadReadyNotification"]
      | components["schemas"]["SecretKeysResultNotification"]
      | components["schemas"]["CacheClearedNotification"]
      | components["schemas"]["CacheInfoNotification"]
      | components["schemas"]["FocusCellNotification"]
      | components["schemas"]["ActiveLineNotification"]
      | components["schemas"]["NotebookDocumentTransactionNotification"]
      | components["schemas"]["ConsumerCapabilitiesNotification"];
    /**
     * OpenAiConfig
     * @description Configuration options for OpenAI or OpenAI-compatible services.
     *
     *         **Keys.**
     *
     *         - `api_key`: the OpenAI API key or an `env:` reference
     *         - `base_url`: the base URL for the API
     *         - `project`: the project ID for the OpenAI API
     *         - `ssl_verify` : Boolean argument for httpx passed to open ai client. httpx defaults to true, but some use cases to let users override to False in some testing scenarios
     *         - `ca_bundle_path`: custom ca bundle to be used for verifying SSL certificates. Used to create custom SSL context for httpx client
     *         - `client_pem` : custom path of a client .pem cert used for verifying identity of client server
     *         - `extra_headers`: extra headers to be passed to the OpenAI client
     */
    OpenAiConfig: {
      api_key?: string;
      base_url?: string;
      ca_bundle_path?: string;
      client_pem?: string;
      extra_headers?: {
        [key: string]: string;
      };
      model?: string;
      project?: string;
      ssl_verify?: boolean;
    };
    /**
     * OpenGraphMetadata
     * @description OpenGraph-style metadata for a notebook.
     *
     *         The `image` field may be either:
     *         - a relative path (typically under `__marimo__/`), or
     *         - an absolute HTTPS URL.
     */
    OpenGraphMetadata: {
      /** @default null */
      description?: string | null;
      /** @default null */
      image?: string | null;
      /** @default null */
      title?: string | null;
    };
    /** OpenTutorialRequest */
    OpenTutorialRequest: {
      tutorialId:
        | (
            | "dataflow"
            | "external-dependencies"
            | "fileformat"
            | "for-jupyter-users"
            | "intro"
            | "layout"
            | "markdown"
            | "plots"
            | "sql"
            | "ui"
          )
        | "markdown-format";
    };
    /** OperationCancelled */
    OperationCancelled: {
      /** @enum {unknown} */
      kind: "cancelled";
    };
    /** OperationFailed */
    OperationFailed: {
      error: string;
      /** @enum {unknown} */
      kind: "failed";
    };
    /** OperationRestartRequired */
    OperationRestartRequired: {
      /** @enum {unknown} */
      kind: "restart-required";
      reason: string;
    };
    /** OperationRunning */
    OperationRunning: {
      /** @enum {unknown} */
      kind: "running";
    };
    /** OperationSucceeded */
    OperationSucceeded: {
      /** @enum {unknown} */
      kind: "succeeded";
    };
    /** PackageDescription */
    PackageDescription: {
      name: string;
      version: string;
    };
    /**
     * PackageManagementConfig
     * @description Configuration options for package management.
     *
     *         **Keys.**
     *
     *         - `manager`: the package manager to use
     */
    PackageManagementConfig: {
      /** @enum {unknown} */
      manager: "pip" | "pixi" | "poetry" | "rye" | "uv";
    };
    /** PackageManagerContext */
    PackageManagerContext: {
      /** @enum {unknown} */
      kind: "package-manager";
      name: string;
    };
    /** PackageOperationResponse */
    PackageOperationResponse: {
      /** @default null */
      error?: string | null;
      /** @default false */
      restartRequired?: boolean;
      success: boolean;
    };
    /**
     * PreviewDatasetColumnCommand
     * @description Preview a dataset column.
     *
     *         Retrieves and displays data from a single column (dataframe or SQL table).
     *         Used by the data explorer UI.
     *
     *         Attributes:
     *             source_type: Data source type ('dataframe', 'sql', etc.).
     *             source: Source identifier (connection string or variable name).
     *             table_name: Table or dataframe variable name.
     *             column_name: Column to preview.
     *             fully_qualified_table_name: Full database.schema.table name for SQL.
     */
    PreviewDatasetColumnCommand: {
      columnName: string;
      /** @default null */
      fullyQualifiedTableName?: string | null;
      source: string;
      /** @enum {unknown} */
      sourceType: "catalog" | "connection" | "duckdb" | "local";
      tableName: string;
      /** @enum {unknown} */
      type: "preview-dataset-column";
    };
    /** PreviewDatasetColumnRequest */
    PreviewDatasetColumnRequest: {
      columnName: string;
      /** @default null */
      fullyQualifiedTableName?: string | null;
      source: string;
      /** @enum {unknown} */
      sourceType: "catalog" | "connection" | "duckdb" | "local";
      tableName: string;
    };
    /**
     * PreviewSQLTableCommand
     * @description Preview SQL table details.
     *
     *         Retrieves metadata and sample data for a table. Used by the SQL editor
     *         and data explorer.
     *
     *         Attributes:
     *             request_id: Unique identifier for this request.
     *             engine: SQL engine ('postgresql', 'mysql', 'duckdb', etc.).
     *             database: Database containing the table.
     *             schema: Schema containing the table.
     *             table_name: Table to preview.
     *             schema_path: Path of nested schemas (relative to `database`) for
     *                 catalogs with nested schemas. Empty for the top level.
     */
    PreviewSQLTableCommand: {
      database: string;
      engine: string;
      requestId: components["schemas"]["RequestId"];
      schema: string;
      /** @default [] */
      schemaPath?: string[];
      tableName: string;
      /** @enum {unknown} */
      type: "preview-sql-table";
    };
    /** PreviewSQLTableRequest */
    PreviewSQLTableRequest: {
      database: string;
      engine: string;
      requestId: components["schemas"]["RequestId"];
      schema: string;
      /** @default [] */
      schemaPath?: string[];
      tableName: string;
    };
    /**
     * PyreflyLanguageServerConfig
     * @description Configuration options for Pyrefly Language Server.
     *
     *     Pyrefly handles completion, hover, go-to-definition, and diagnostics.
     */
    PyreflyLanguageServerConfig: {
      enabled?: boolean;
    };
    /**
     * PythonLanguageServerConfig
     * @description Configuration options for Python Language Server.
     *
     *     pylsp handles completion, hover, go-to-definition, and diagnostics.
     */
    PythonLanguageServerConfig: {
      enable_flake8?: boolean;
      enable_mypy?: boolean;
      enable_pydocstyle?: boolean;
      enable_pyflakes?: boolean;
      enable_pylint?: boolean;
      enable_ruff?: boolean;
      enabled?: boolean;
    };
    /**
     * QueryParamsAppendNotification
     * @description Appends value to URL query parameter.
     *
     *         Attributes:
     *             key: Query parameter key.
     *             value: Value to append.
     */
    QueryParamsAppendNotification: {
      key: string;
      /** @enum {unknown} */
      op: "query-params-append";
      value: string;
    };
    /**
     * QueryParamsClearNotification
     * @description Clears all URL query parameters.
     */
    QueryParamsClearNotification: {
      /** @enum {unknown} */
      op: "query-params-clear";
    };
    /**
     * QueryParamsDeleteNotification
     * @description Deletes URL query parameter values.
     *
     *         Attributes:
     *             key: Query parameter key.
     *             value: Specific value to delete. If None, deletes all values for key.
     */
    QueryParamsDeleteNotification: {
      key: string;
      /** @enum {unknown} */
      op: "query-params-delete";
      value: string | null;
    };
    /**
     * QueryParamsSetNotification
     * @description Sets URL query parameter, replacing existing values.
     *
     *         Attributes:
     *             key: Query parameter key.
     *             value: Value(s) to set.
     */
    QueryParamsSetNotification: {
      key: string;
      /** @enum {unknown} */
      op: "query-params-set";
      value: string | string[];
    };
    /** ReadCodeResponse */
    ReadCodeResponse: {
      contents: string;
    };
    /** RecentFilesResponse */
    RecentFilesResponse: {
      files: components["schemas"]["MarimoFile"][];
    };
    /**
     * ReconnectedNotification
     * @description WebSocket reconnection confirmed.
     */
    ReconnectedNotification: {
      /** @enum {unknown} */
      op: "reconnected";
    };
    /**
     * ReloadNotification
     * @description Instructs frontend to reload the page.
     */
    ReloadNotification: {
      /** @enum {unknown} */
      op: "reload";
    };
    /** RemovePackageRequest */
    RemovePackageRequest: {
      /** @default null */
      group?: string | null;
      package: string;
    };
    /**
     * RemoveUIElementsNotification
     * @description Removes UI elements associated with a cell.
     *
     *         Sent when cell is re-executed or deleted.
     *
     *         Attributes:
     *             cell_id: Cell whose UI elements should be removed.
     */
    RemoveUIElementsNotification: {
      cell_id: components["schemas"]["CellId"];
      /** @enum {unknown} */
      op: "remove-ui-elements";
    };
    /** RenameNotebookRequest */
    RenameNotebookRequest: {
      filename: string;
    };
    /**
     * ReorderCells
     * @description Replace the full cell ordering.
     *
     *         Cell IDs present in the document but missing from `cell_ids`
     *         are appended at the end. IDs not in the document are ignored.
     */
    ReorderCells: {
      cellIds: components["schemas"]["CellId"][];
      /** @enum {unknown} */
      type: "reorder-cells";
    };
    /** Format: request-id */
    RequestId: TypedString<"RequestId">;
    /** Revision */
    Revision: {
      /** @description Identifies an execution. Unique within the host. */
      execution: string;
      /** @description How many times the value has been updated since it was produced. Zero at binding. */
      update: number;
    };
    /** RunningNotebooksResponse */
    RunningNotebooksResponse: {
      files: components["schemas"]["MarimoFile"][];
    };
    /**
     * RuntimeConfig
     * @description Configuration for runtime.
     *
     *         **Keys.**
     *
     *         - `auto_instantiate`: if `False`, cells won't automatically
     *             run on startup. This only applies when editing a notebook,
     *             and not when running as an application.
     *             The default is `True`.
     *         - `auto_reload`: if `lazy`, cells importing modified modules will marked
     *           as stale; if `autorun`, affected cells will be automatically run. similar
     *           to IPython's %autoreload extension but with more code intelligence.
     *         - `reactive_tests`: if `True`, marimo will automatically run pytest on cells containing only test functions and test classes.
     *           execution.
     *         - `on_cell_change`: if `lazy`, cells will be marked stale when their
     *           ancestors run but won't autorun; if `autorun`, cells will automatically
     *           run when their ancestors run.
     *         - `execution_type`: if `relaxed`, marimo will not clone cell declarations;
     *           if `strict` marimo will clone cell declarations by default, avoiding
     *           hidden potential state build up.
     *         - `watcher_on_save`: how to handle file changes when saving. `"lazy"` marks
     *             affected cells as stale, `"autorun"` automatically runs affected cells.
     *         - `output_max_bytes`: the maximum size in bytes of cell outputs; larger
     *             values may affect frontend performance
     *         - `serve_cached_sessions_in_apps`: if `True`, initialize applications with session cache.
     *             The default is `False`.
     *         - `std_stream_max_bytes`: the maximum size in bytes of console outputs;
     *           larger values may affect frontend performance
     *         - `pythonpath`: a list of directories to add to the Python search path.
     *             Directories will be added to the head of sys.path. Similar to the
     *             `PYTHONPATH` environment variable, the directories will be included in
     *             where Python will look for imported modules.
     *         - `dotenv`: a list of paths to `.env` files to load.
     *             If the file does not exist, it will be silently ignored. Relative
     *             paths resolve against the directory holding the `pyproject.toml`,
     *             or the notebook's directory when there is none. The default is
     *             `[".env"]`.
     *         - `default_sql_output`: the default output format for SQL queries. Can be one of:
     *             `"auto"`, `"native"`, `"polars"`, `"lazy-polars"`, or `"pandas"`.
     *             The default is `"auto"`.
     *         - `default_auto_download`: an Optional list of export types to automatically snapshot your notebook as:
     *            `html`, `markdown`, `ipynb`.
     *            The default is None.
     *         - `default_csv_encoding`: the default encoding for CSV exports.
     *             The default is `"utf-8"`.
     *         - `show_tracebacks`: if `True`, show detailed error tracebacks in run mode.
     *             When enabled, exceptions will display a clickable toast that opens a modal with the full traceback.
     *             The default is `False`.
     */
    RuntimeConfig: {
      auto_instantiate: boolean;
      /** @enum {unknown} */
      auto_reload: "autorun" | "lazy" | "off";
      default_auto_download?: ("html" | "ipynb" | "markdown")[];
      default_csv_encoding?: string;
      /** @enum {unknown} */
      default_sql_output:
        | "auto"
        | "lazy-polars"
        | "native"
        | "pandas"
        | "polars";
      dotenv?: string[];
      /** @enum {unknown} */
      on_cell_change: "autorun" | "lazy";
      output_max_bytes: number;
      pythonpath?: string[];
      reactive_tests: boolean;
      serve_cached_sessions_in_apps?: boolean;
      show_tracebacks?: boolean;
      std_stream_max_bytes: number;
      /** @enum {unknown} */
      watcher_on_save: "autorun" | "lazy";
    };
    /**
     * SQLDatabaseMetadata
     * @description SQL database metadata.
     *
     *         Attributes:
     *             connection: Connection identifier.
     *             database: Database name.
     *             schema_path: Parent schema path the schemas belong under. Empty for
     *                 the database's top level.
     */
    SQLDatabaseMetadata: {
      connection: string;
      database: string;
      /** @default [] */
      schema_path?: string[];
    };
    /**
     * SQLMetadata
     * @description SQL database and schema metadata.
     *
     *         Attributes:
     *             connection: Connection identifier.
     *             database: Database name.
     *             schema: Schema name.
     *             schema_path: Path of nested schemas (relative to `database`). Empty
     *                 for the top level.
     */
    SQLMetadata: {
      connection: string;
      database: string;
      schema: string;
      /** @default [] */
      schema_path?: string[];
      /** @enum {unknown} */
      type: "sql-metadata";
    };
    /**
     * SQLSchemaListPreviewNotification
     * @description List of SQL schemas in a database.
     *
     *         Attributes:
     *             request_id: Request ID this responds to.
     *             metadata: Database and schema metadata.
     *             schemas: Schemas in database.
     *             error: Error message if failed.
     */
    SQLSchemaListPreviewNotification: {
      /** @default null */
      error?: string | null;
      metadata: components["schemas"]["SQLDatabaseMetadata"];
      /** @enum {unknown} */
      op: "sql-schema-list-preview";
      request_id: components["schemas"]["RequestId"];
      /** @default [] */
      schemas?: components["schemas"]["Schema"][];
    };
    /**
     * SQLTableListPreviewNotification
     * @description List of SQL tables in a schema.
     *
     *         Attributes:
     *             request_id: Request ID this responds to.
     *             metadata: Database and schema metadata.
     *             tables: Tables in schema.
     *             error: Error message if failed.
     */
    SQLTableListPreviewNotification: {
      /** @default null */
      error?: string | null;
      metadata: components["schemas"]["SQLMetadata"];
      /** @enum {unknown} */
      op: "sql-table-list-preview";
      request_id: components["schemas"]["RequestId"];
      /** @default [] */
      tables?: components["schemas"]["DataTable"][];
    };
    /**
     * SQLTablePreviewNotification
     * @description SQL table preview.
     *
     *         Attributes:
     *             request_id: Request ID this responds to.
     *             metadata: Database and schema metadata.
     *             table: Table data (None if error).
     *             error: Error message if failed.
     */
    SQLTablePreviewNotification: {
      /** @default null */
      error?: string | null;
      metadata: components["schemas"]["SQLMetadata"];
      /** @enum {unknown} */
      op: "sql-table-preview";
      request_id: components["schemas"]["RequestId"];
      table: components["schemas"]["DataTable"] | null;
    };
    /**
     * SafeLiteralDiscoveryValue
     * @description Non-sensitive metadata that is safe to send to the frontend.
     */
    SafeLiteralDiscoveryValue: {
      /** @enum {unknown} */
      kind: "safe-literal";
      value: string;
    };
    /** SandboxPackageContext */
    SandboxPackageContext: {
      /** @enum {unknown} */
      backend: "pixi" | "uv";
      /** @enum {unknown} */
      kind: "sandbox";
    };
    /** SandboxRequest */
    SandboxRequest: {
      /** @default null */
      fileKey?: string | null;
    };
    /** SandboxResponse */
    SandboxResponse: {
      backend: ("pixi" | "uv") | null;
      filename: string | null;
      manifest: string | null;
    };
    /** SaveAppConfigurationRequest */
    SaveAppConfigurationRequest: {
      config: Record<string, any>;
    };
    /**
     * SaveConfig
     * @description Configuration for saving.
     *
     *         **Keys.**
     *
     *         - `autosave`: one of `"off"` or `"after_delay"`
     *         - `delay`: number of milliseconds to wait before autosaving
     *         - `format_on_save`: if `True`, format the code on save
     */
    SaveConfig: {
      /** @enum {unknown} */
      autosave: "after_delay" | "off";
      autosave_delay: number;
      format_on_save: boolean;
    };
    /**
     * SaveLayoutRequest
     * @description The notebook's layout, written beside it; `None` removes it.
     */
    SaveLayoutRequest: {
      /** @default null */
      layout?: Record<string, any> | null;
    };
    /** SaveUserConfigurationRequest */
    SaveUserConfigurationRequest: {
      config: Record<string, any>;
    };
    /**
     * Schema
     * @description Represents a database schema and its tables.
     *
     *     A schema may itself contain nested child schemas, e.g. for catalogs with
     *     hierarchical namespaces such as Iceberg (`top.nested.deep`).
     *
     *     Attributes:
     *         name (str): The name of the schema.
     *         tables (List[DataTable]): Tables in this schema.
     *         tables_resolved (bool): True when `tables` has been enumerated
     *             False when table discovery was deferred. Defaults to True
     *         child_schemas (List[Schema]): Nested child schemas (sub-namespaces).
     *         child_schemas_resolved (bool): True when `child_schemas` has been
     *             enumerated. False when discovery was deferred. Defaults to True
     */
    Schema: {
      /** @default [] */
      child_schemas?: components["schemas"]["Schema"][];
      /** @default true */
      child_schemas_resolved?: boolean;
      name: string;
      tables: components["schemas"]["DataTable"][];
      /** @default true */
      tables_resolved?: boolean;
    };
    /** SchemaColumn */
    SchemaColumn: {
      name: string;
      sampleValues: unknown[];
      type: string;
    };
    /** SchemaTable */
    SchemaTable: {
      columns: components["schemas"]["SchemaColumn"][];
      name: string;
    };
    /**
     * SecretKeysResultNotification
     * @description Available secret keys from secret providers.
     *
     *         Attributes:
     *             request_id: Request ID this responds to.
     *             secrets: Secret keys with provider info.
     */
    SecretKeysResultNotification: {
      /** @enum {unknown} */
      op: "secret-keys-result";
      request_id: components["schemas"]["RequestId"];
      secrets: components["schemas"]["SecretKeysWithProvider"][];
    };
    /** SecretKeysWithProvider */
    SecretKeysWithProvider: {
      keys: string[];
      name: string;
      /** @enum {unknown} */
      provider: "dotenv" | "env";
    };
    /**
     * ServerConfig
     * @description Configuration for the server.
     *
     *         **Keys.**
     *
     *         - `browser`: the web browser to use. `"default"` or a browser registered
     *             with Python's webbrowser module (eg, `"firefox"` or `"chrome"`)
     *         - `follow_symlink`: if true, the server will follow symlinks it finds
     *             inside its static assets directory.
     *         - `disable_file_downloads`: if true, the file download button will be
     *             hidden in the file explorer.
     *         - `transport`: experimental. The transport used to stream kernel
     *             messages to the frontend, typically set with the
     *             `MARIMO_SERVER_TRANSPORT` environment variable. `"websocket"`
     *             (default) uses the `/ws` WebSocket endpoint; `"sse"` uses
     *             server-sent events over HTTP, for deployments behind proxies or
     *             services that do not support WebSockets. The terminal and LSP
     *             still require WebSockets.
     */
    ServerConfig: {
      browser: "default" | string;
      disable_file_downloads?: boolean;
      follow_symlink: boolean;
      /** @enum {unknown} */
      transport?: "sse" | "websocket";
    };
    /** Format: session-id */
    SessionId: TypedString<"SessionId">;
    /** SetBreakpointsRequest */
    SetBreakpointsRequest: {
      breakpoints: {
        [key: string]: number[];
      };
      /** @default null */
      request?: components["schemas"]["HTTPRequest"] | null;
    };
    /**
     * SetCode
     * @description Replace a cell's source code.
     */
    SetCode: {
      cellId: components["schemas"]["CellId"];
      code: string;
      /** @enum {unknown} */
      type: "set-code";
    };
    /**
     * SetConfig
     * @description Replace a cell's config.
     */
    SetConfig: {
      cellId: components["schemas"]["CellId"];
      column: number | null;
      disabled: boolean;
      expandOutput: boolean;
      hideCode: boolean;
      /** @enum {unknown} */
      type: "set-config";
    };
    /**
     * SetName
     * @description Rename a cell.
     */
    SetName: {
      cellId: components["schemas"]["CellId"];
      name: string;
      /** @enum {unknown} */
      type: "set-name";
    };
    /** SetupRootError */
    SetupRootError: {
      edges_with_vars: [string, string[], string][];
      /** @enum {unknown} */
      type: "setup-refs";
    };
    /**
     * SharingConfig
     * @description Configuration for sharing features.
     *
     *         **Keys.**
     *
     *         - `html`: if `False`, HTML sharing options will be hidden from the UI
     *         - `wasm`: if `False`, WebAssembly sharing options will be hidden from the UI
     *         - `molab`: if `False`, molab sharing options will be hidden from the UI
     */
    SharingConfig: {
      html?: boolean;
      molab?: boolean;
      wasm?: boolean;
    };
    /** ShutdownSessionRequest */
    ShutdownSessionRequest: {
      sessionId: components["schemas"]["SessionId"];
    };
    /**
     * SigningConfig
     * @description Cache-signing trust and identity.
     *
     *         `trusted_signers` maps a key fingerprint (`"SHA256:<base64>"`) to an
     *         advisory label. Trusting a key allows arbitrary code execution from its
     *         holder on this machine — a cache restore is `pickle.loads` — so there is no
     *         lesser cache-only grant. `private_key_path` is this machine's signing
     *         identity; it is never serialized to the frontend.
     */
    SigningConfig: {
      private_key_path?: string;
      trusted_signers?: {
        [key: string]: string;
      };
    };
    /** Snippet */
    Snippet: {
      sections: components["schemas"]["SnippetSection"][];
      title: string;
    };
    /** SnippetSection */
    SnippetSection: {
      /** @default null */
      code?: string | null;
      /** @default null */
      html?: string | null;
      id: string;
    };
    /** Snippets */
    Snippets: {
      snippets: components["schemas"]["Snippet"][];
    };
    /**
     * SnippetsConfig
     * @description Configuration for snippets.
     *
     *         **Keys.**
     *
     *         - `custom_path`: the path to the custom snippets directory
     */
    SnippetsConfig: {
      custom_paths?: string[];
      include_default_snippets?: boolean;
    };
    /**
     * SqlCatalogCheckResult
     * @description Result of running validation against the database.
     */
    SqlCatalogCheckResult: {
      error_message: string | null;
      success: boolean;
    };
    /**
     * SqlParseError
     * @description Represents a single SQL parse error.
     *
     *     Attributes:
     *         message (str): Description of the error.
     *         line (int): Line number where the error occurred (1-based).
     *         column (int): Column number where the error occurred (1-based).
     *         severity (Literal["error", "warning"]): Severity of the error.
     */
    SqlParseError: {
      column: number;
      line: number;
      message: string;
      /** @enum {unknown} */
      severity: "error" | "warning";
    };
    /**
     * SqlParseResult
     * @description Result of parsing an SQL query.
     *
     *     Attributes:
     *         success (bool): True if parsing succeeded without errors.
     *         errors (list[SqlParseError]): List of parse errors (empty if success is True).
     */
    SqlParseResult: {
      errors: components["schemas"]["SqlParseError"][];
      success: boolean;
    };
    /**
     * StartupLogsNotification
     * @description Streaming kernel startup logs.
     *
     *         Attributes:
     *             content: Log content to display.
     *             status: Stream status (start/append/done).
     */
    StartupLogsNotification: {
      content: string;
      /** @enum {unknown} */
      op: "startup-logs";
      /** @enum {unknown} */
      status: "append" | "done" | "start";
    };
    /**
     * StartupProgressNotification
     * @description Current startup phase and its output before the kernel is ready.
     *
     *         Output appends within a phase. Snapshots replace it, and changing phases
     *         starts a new stream. Environment preparation logs belong to its operation.
     */
    StartupProgressNotification: {
      /** @enum {unknown} */
      log_mode: "append" | "replace";
      logs: string;
      /** @enum {unknown} */
      op: "startup-progress";
      /** @enum {unknown} */
      phase: "preparing-environment" | "starting-kernel";
    };
    /** StdinRequest */
    StdinRequest: {
      text: string;
    };
    /**
     * StorageDownloadReadyNotification
     * @description Signals that a storage file download is ready.
     *
     *         The url may be a signed cloud URL (preferred) or a virtual file URL
     *         (fallback for backends that don't support signing).
     *
     *         Attributes:
     *             request_id: Request ID this responds to.
     *             url: Signed or virtual-file URL to download from.
     *             filename: Suggested filename for the download.
     *             error: Error message if the download failed.
     */
    StorageDownloadReadyNotification: {
      /** @default null */
      error?: string | null;
      /** @default null */
      filename?: string | null;
      /** @enum {unknown} */
      op: "storage-download-ready";
      request_id: components["schemas"]["RequestId"];
      /** @default null */
      url?: string | null;
    };
    /** StorageDownloadRequest */
    StorageDownloadRequest: {
      namespace: string;
      path: string;
      /** @default false */
      preview?: boolean;
      requestId: components["schemas"]["RequestId"];
    };
    /**
     * StorageEntriesNotification
     * @description Result of a storage operation that returns entries.
     *
     *         Attributes:
     *             request_id: Request ID this responds to.
     *             entries: Storage entries returned by the operation.
     *             namespace: Variable name of the storage backend.
     *             prefix: The prefix that was listed (set by list_entries).
     *             query: The search query that was used (set by search).
     *             next_page_token: Token for fetching the next page of entries.
     *             error: Error message if the operation failed.
     */
    StorageEntriesNotification: {
      entries: components["schemas"]["StorageEntry"][];
      /** @default null */
      error?: string | null;
      namespace: string;
      /** @default null */
      next_page_token?: string | null;
      /** @enum {unknown} */
      op: "storage-entries";
      /** @default null */
      prefix?: string | null;
      /** @default null */
      query?: string | null;
      request_id: components["schemas"]["RequestId"];
    };
    /**
     * StorageEntry
     * @description A storage entry is a file, directory, or object for external storage systems
     *
     *         Attributes:
     *             path: The path of the storage entry.
     *             kind: The kind of the storage entry.
     *             size: The size of the storage entry.
     *             last_modified: The last modified time of the storage entry.
     *             metadata: The metadata of the storage entry.
     *             mime_type: The MIME type of the storage entry, or None for directories.
     */
    StorageEntry: {
      /** @enum {unknown} */
      kind: "directory" | "file" | "object";
      lastModified: number | null;
      /** @default {} */
      metadata?: Record<string, any>;
      /** @default null */
      mimeType?: string | null;
      path: string;
      size: number;
    };
    /**
     * StorageHidesWhen
     * @description Hide this suggestion when a live storage namespace matches.
     */
    StorageHidesWhen: {
      backendTypes: string[];
      /** @enum {unknown} */
      kind: "storage";
      protocols: string[];
    };
    /** StorageListEntriesRequest */
    StorageListEntriesRequest: {
      limit: number;
      namespace: string;
      /** @default null */
      pageToken?: string | null;
      /** @default null */
      prefix?: string | null;
      requestId: components["schemas"]["RequestId"];
    };
    /**
     * StorageNamespace
     * @description Represents external storage systems (filesystems and object storage)
     *
     *         Attributes:
     *             name: The variable name of the storage namespace.
     *             display_name: The display name of the storage namespace.
     *             protocol: The protocol of the storage namespace. E.g. s3, gcs, azure, http, file, in-memory.
     *             root_path: The root path of the storage namespace.
     *             backend_type: The type of the storage backend (fsspec or obstore)
     *             storage_entries: The storage entries in the storage namespace.
     */
    StorageNamespace: {
      /** @enum {unknown} */
      backendType: "fsspec" | "huggingface" | "obstore";
      displayName: string;
      name: components["schemas"]["VariableName"];
      protocol: string;
      rootPath: string;
      storageEntries: components["schemas"]["StorageEntry"][];
    };
    /**
     * StorageNamespacesNotification
     * @description Available storage namespaces for storage inspector.
     *
     *         Attributes:
     *             namespaces: Available storage namespaces.
     */
    StorageNamespacesNotification: {
      namespaces: components["schemas"]["StorageNamespace"][];
      /** @enum {unknown} */
      op: "storage-namespaces";
    };
    /**
     * StoreConfig
     * @description Configuration for a single cache store.
     */
    StoreConfig: {
      args?: Record<string, any>;
      /** @enum {unknown} */
      type?: "file" | "redis" | "rest" | "tiered";
    };
    /** SuccessResponse */
    SuccessResponse: {
      /** @default true */
      success?: boolean;
    };
    /** SyncSandboxResponse */
    SyncSandboxResponse: {
      /** @default null */
      error?: string | null;
      /** @default false */
      reconnect?: boolean;
      /** @default false */
      restartRequired?: boolean;
      success: boolean;
    };
    /**
     * ToolDefinition
     * @description Tool definition compatible with ai-sdk-ui format.
     */
    ToolDefinition: {
      description: string;
      mode: ("agent" | "ask" | "code_mode" | "manual")[];
      name: string;
      parameters: Record<string, any>;
      /** @enum {unknown} */
      source: "backend" | "frontend" | "mcp";
    };
    /**
     * Transaction
     * @description An atomic batch of changes applied to a NotebookDocument.
     *
     *         `source` identifies the writer (e.g. `"frontend"`, `"kernel"`).
     *         `version` is `None` when created and stamped by
     *         `NotebookDocument.apply()`.
     */
    Transaction: {
      changes: (
        | components["schemas"]["CreateCell"]
        | components["schemas"]["DeleteCell"]
        | components["schemas"]["MoveCell"]
        | components["schemas"]["ReorderCells"]
        | components["schemas"]["SetCode"]
        | components["schemas"]["SetName"]
        | components["schemas"]["SetConfig"]
      )[];
      /** @enum {unknown} */
      source:
        | "cell-manager"
        | "code-mode"
        | "file-watch"
        | "frontend"
        | "host"
        | "kernel";
      /** @default null */
      version?: number | null;
    };
    /**
     * TyLanguageServerConfig
     * @description Configuration options for Ty Language Server.
     *
     *     ty handles completion, hover, go-to-definition, and diagnostics,
     *     but we only use it for diagnostics.
     */
    TyLanguageServerConfig: {
      enabled?: boolean;
    };
    /** Format: ui-element-id */
    UIElementId: `${components["schemas"]["CellId"]}-${string}`;
    /**
     * UIElementMessageNotification
     * @description Sends a message to a UI element/widget.
     *
     *         Attributes:
     *             ui_element: UI element identifier.
     *             message: Message payload as dictionary.
     *             buffers: Optional binary buffers for large data.
     */
    UIElementMessageNotification: {
      /** @default null */
      buffers?: components["schemas"]["Base64String"][] | null;
      message: Record<string, any>;
      /** @enum {unknown} */
      op: "send-ui-element-message";
      ui_element: components["schemas"]["UIElementId"];
    };
    /** UnknownError */
    UnknownError: {
      /** @default null */
      error_type?: string | null;
      msg: string;
      /** @enum {unknown} */
      type: "unknown";
    };
    /**
     * UpdateCellConfigCommand
     * @description Update cell configuration.
     *
     *         Updates cell-level settings like disabled state, hide code, etc.
     *
     *         Attributes:
     *             configs: Cell IDs mapped to their config updates. Each config dict
     *                      can contain partial updates.
     */
    UpdateCellConfigCommand: {
      configs: {
        [key: string]: Record<string, any>;
      };
      /** @enum {unknown} */
      type: "update-cell-config";
    };
    /** UpdateCellOutputsRequest */
    UpdateCellOutputsRequest: {
      cellIdsToOutput: {
        [key: string]: [
          (
            | "application/json"
            | "application/vnd.jupyter.widget-view+json"
            | "application/vnd.marimo+error"
            | "application/vnd.marimo+mimebundle"
            | "application/vnd.marimo+traceback"
            | "application/vnd.vega.v5+json"
            | "application/vnd.vega.v6+json"
            | "application/vnd.vegalite.v5+json"
            | "application/vnd.vegalite.v6+json"
            | "image/avif"
            | "image/bmp"
            | "image/gif"
            | "image/jpeg"
            | "image/png"
            | "image/svg+xml"
            | "image/tiff"
            | "text/csv"
            | "text/html"
            | "text/latex"
            | "text/markdown"
            | "text/password"
            | "text/plain"
            | "video/mp4"
            | "video/mpeg"
          ),
          unknown,
        ];
      };
    };
    /** UpdateManifestRequest */
    UpdateManifestRequest: {
      contents: string;
      /** @default null */
      fileKey?: string | null;
      previous: string;
    };
    /**
     * UpdateUIElementCommand
     * @description Update UI element values.
     *
     *         Triggered when users interact with UI elements (sliders, inputs, dropdowns, etc.).
     *         Updates element values and re-executes dependent cells.
     *
     *         Attributes:
     *             object_ids: UI elements to update.
     *             values: New values for the elements. Must match length of object_ids.
     *             request: HTTP request context if available.
     *             token: Unique request identifier for deduplication.
     */
    UpdateUIElementCommand: {
      objectIds: components["schemas"]["UIElementId"][];
      /** @default null */
      request?: components["schemas"]["HTTPRequest"] | null;
      token?: string;
      /** @enum {unknown} */
      type: "update-ui-element";
      values: unknown[];
    };
    /** UpdateUIElementRequest */
    UpdateUIElementRequest: {
      objectIds: components["schemas"]["UIElementId"][];
      /** @default null */
      request?: components["schemas"]["HTTPRequest"] | null;
      token?: string;
      values: unknown[];
    };
    /** UpdateUIElementValuesRequest */
    UpdateUIElementValuesRequest: {
      objectIds: components["schemas"]["UIElementId"][];
      values: unknown[];
    };
    /** UpdateUserConfigRequest */
    UpdateUserConfigRequest: {
      config: components["schemas"]["MarimoConfig"];
    };
    /**
     * ValidateSQLCommand
     * @description Validate an SQL query.
     *
     *         Checks if an SQL query is valid by parsing against a dialect (no DB connection)
     *         or validating against an actual database.
     *
     *         Attributes:
     *             request_id: Unique identifier for this request.
     *             query: SQL query to validate.
     *             only_parse: If True, only parse using dialect. If False, validate against DB.
     *             engine: SQL engine (required if only_parse is False).
     *             dialect: SQL dialect for parsing (required if only_parse is True).
     */
    ValidateSQLCommand: {
      /** @default null */
      dialect?: string | null;
      /** @default null */
      engine?: string | null;
      onlyParse: boolean;
      query: string;
      requestId: components["schemas"]["RequestId"];
      /** @enum {unknown} */
      type: "validate-sql";
    };
    /** ValidateSQLRequest */
    ValidateSQLRequest: {
      /** @default null */
      dialect?: string | null;
      /** @default null */
      engine?: string | null;
      onlyParse: boolean;
      query: string;
      requestId: components["schemas"]["RequestId"];
    };
    /**
     * ValidateSQLResultNotification
     * @description SQL query validation result.
     *
     *         Attributes:
     *             request_id: Request ID this responds to.
     *             parse_result: SQL parsing result.
     *             validate_result: Catalog validation result.
     *             error: Error message if failed.
     */
    ValidateSQLResultNotification: {
      /** @default null */
      error?: string | null;
      /** @enum {unknown} */
      op: "validate-sql-result";
      /** @default null */
      parse_result?: components["schemas"]["SqlParseResult"] | null;
      request_id: components["schemas"]["RequestId"];
      /** @default null */
      validate_result?: components["schemas"]["SqlCatalogCheckResult"] | null;
    };
    /** VariableContext */
    VariableContext: {
      name: string;
      previewValue: unknown;
      valueType: string;
    };
    /**
     * VariableDeclarationNotification
     * @description Variable declaration and usage for dataflow graph.
     *
     *         Attributes:
     *             name: Variable name.
     *             declared_by: Cell IDs that define this variable.
     *             used_by: Cell IDs that use this variable.
     */
    VariableDeclarationNotification: {
      declared_by: components["schemas"]["CellId"][];
      name: components["schemas"]["VariableName"];
      used_by: components["schemas"]["CellId"][];
    };
    /** Format: variable-name */
    VariableName: TypedString<"VariableName">;
    /**
     * VariableRemoval
     * @description A binding removed from the runtime's namespace.
     */
    VariableRemoval: {
      execution_id: string;
      name: string;
    };
    /**
     * VariableValue
     * @description Variable value and type for variables panel.
     *
     *         Attributes:
     *             name: Variable name.
     *             value: String representation of value.
     *             datatype: Data type as string.
     */
    VariableValue: {
      datatype: string | null;
      /** @default null */
      execution_id?: string | null;
      name: string;
      /** @default null */
      revision?: components["schemas"]["Revision"] | null;
      value: string | null;
    };
    /**
     * VariableValuesNotification
     * @description Current variable values.
     *
     *         Attributes:
     *             variables: Variables with current values and types.
     *             removed: Bindings that no longer exist, identified by their producer.
     */
    VariableValuesNotification: {
      /** @enum {unknown} */
      op: "variable-values";
      /** @default [] */
      removed?: components["schemas"]["VariableRemoval"][];
      variables: components["schemas"]["VariableValue"][];
    };
    /**
     * VariablesNotification
     * @description Variable dataflow graph.
     *
     *         Attributes:
     *             variables: Variable declarations and usage.
     */
    VariablesNotification: {
      /** @enum {unknown} */
      op: "variables";
      variables: components["schemas"]["VariableDeclarationNotification"][];
    };
    /**
     * VenvConfig
     * @description Configuration for an external Python environment in edit mode.
     *
     *         Launches the notebook kernel in an existing virtualenv. Applies to
     *         single notebooks and directories when editing without `--sandbox`.
     *
     *         **Keys.**
     *
     *         - `path`: path to a virtualenv directory (absolute or relative to
     *           pyproject.toml)
     *         - `writable`: if true, marimo will manage script metadata (inline
     *           dependencies). Defaults to false.
     */
    VenvConfig: {
      path?: string;
      writable?: boolean;
    };
    /** Format: widget-model-id */
    WidgetModelId: TypedString<"WidgetModelId">;
    /** WorkspaceFilesRequest */
    WorkspaceFilesRequest: {
      /** @default false */
      includeMarkdown?: boolean;
    };
    /** WorkspaceFilesResponse */
    WorkspaceFilesResponse: {
      /** @default 0 */
      fileCount?: number;
      files: components["schemas"]["FileInfo"][];
      /** @default false */
      hasMore?: boolean;
      root: string;
    };
    /**
     * _AppConfig
     * @description Program-specific configuration.
     *
     *         Configuration for frontends or runtimes that is specific to
     *         a single marimo program.
     */
    _AppConfig: {
      /** @default null */
      app_title?: string | null;
      auto_download?: ("html" | "ipynb" | "markdown")[];
      /** @default null */
      css_file?: string | null;
      /** @default null */
      html_head_file?: string | null;
      /** @default null */
      layout_file?: string | null;
      /**
       * @default auto
       * @enum {unknown}
       */
      sql_output?: "auto" | "lazy-polars" | "native" | "pandas" | "polars";
      /**
       * @default compact
       * @enum {unknown}
       */
      width?: "columns" | "compact" | "full" | "medium" | "normal";
    };
  };
  responses: never;
  parameters: never;
  requestBodies: never;
  headers: never;
  pathItems: never;
}
export type $defs = Record<string, any>;
export type operations = Record<string, any>;