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.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
/**
* 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>;