windmill-components 1.558.3 → 1.596.0

package/package/gen/schemas.gen.d.ts

@@ -1,105 +1,158 @@
 export declare const $OpenFlow: {
     readonly type: "object";
+    readonly description: "Top-level flow definition containing metadata, configuration, and the flow structure";
     readonly properties: {
         readonly summary: {
             readonly type: "string";
+            readonly description: "Short description of what this flow does";
         };
         readonly description: {
             readonly type: "string";
+            readonly description: "Detailed documentation for this flow";
         };
         readonly value: {
             readonly $ref: "#/components/schemas/FlowValue";
         };
         readonly schema: {
             readonly type: "object";
+            readonly description: "JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')";
         };
     };
     readonly required: readonly ["summary", "value"];
 };
 export declare const $FlowValue: {
     readonly type: "object";
+    readonly description: "The flow structure containing modules and optional preprocessor/failure handlers";
     readonly properties: {
         readonly modules: {
             readonly type: "array";
+            readonly description: "Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch";
             readonly items: {
                 readonly $ref: "#/components/schemas/FlowModule";
             };
         };
         readonly failure_module: {
+            readonly description: "Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types";
             readonly $ref: "#/components/schemas/FlowModule";
         };
         readonly preprocessor_module: {
+            readonly description: "Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results";
             readonly $ref: "#/components/schemas/FlowModule";
         };
         readonly same_worker: {
             readonly type: "boolean";
+            readonly description: "If true, all steps run on the same worker for better performance";
         };
         readonly concurrent_limit: {
             readonly type: "number";
+            readonly description: "Maximum number of concurrent executions of this flow";
         };
         readonly concurrency_key: {
             readonly type: "string";
+            readonly description: "Expression to group concurrent executions (e.g., by user ID)";
         };
         readonly concurrency_time_window_s: {
             readonly type: "number";
+            readonly description: "Time window in seconds for concurrent_limit";
+        };
+        readonly debounce_delay_s: {
+            readonly type: "number";
+            readonly description: "Delay in seconds to debounce flow executions";
+        };
+        readonly debounce_key: {
+            readonly type: "string";
+            readonly description: "Expression to group debounced executions";
         };
         readonly skip_expr: {
             readonly type: "string";
+            readonly description: "JavaScript expression to conditionally skip the entire flow";
         };
         readonly cache_ttl: {
             readonly type: "number";
+            readonly description: "Cache duration in seconds for flow results";
+        };
+        readonly cache_ignore_s3_path: {
+            readonly type: "boolean";
+        };
+        readonly flow_env: {
+            readonly type: "object";
+            readonly description: "Environment variables available to all steps";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
         };
         readonly priority: {
             readonly type: "number";
+            readonly description: "Execution priority (higher numbers run first)";
         };
         readonly early_return: {
             readonly type: "string";
+            readonly description: "JavaScript expression to return early from the flow";
         };
         readonly chat_input_enabled: {
             readonly type: "boolean";
             readonly description: "Whether this flow accepts chat-style input";
         };
+        readonly notes: {
+            readonly type: "array";
+            readonly description: "Sticky notes attached to the flow";
+            readonly items: {
+                readonly $ref: "#/components/schemas/FlowNote";
+            };
+        };
     };
     readonly required: readonly ["modules"];
 };
 export declare const $Retry: {
     readonly type: "object";
+    readonly description: "Retry configuration for failed module executions";
     readonly properties: {
         readonly constant: {
             readonly type: "object";
+            readonly description: "Retry with constant delay between attempts";
             readonly properties: {
                 readonly attempts: {
                     readonly type: "integer";
+                    readonly description: "Number of retry attempts";
                 };
                 readonly seconds: {
                     readonly type: "integer";
+                    readonly description: "Seconds to wait between retries";
                 };
             };
         };
         readonly exponential: {
             readonly type: "object";
+            readonly description: "Retry with exponential backoff (delay doubles each time)";
             readonly properties: {
                 readonly attempts: {
                     readonly type: "integer";
+                    readonly description: "Number of retry attempts";
                 };
                 readonly multiplier: {
                     readonly type: "integer";
+                    readonly description: "Multiplier for exponential backoff";
                 };
                 readonly seconds: {
                     readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly description: "Initial delay in seconds";
                 };
                 readonly random_factor: {
                     readonly type: "integer";
                     readonly minimum: 0;
                     readonly maximum: 100;
+                    readonly description: "Random jitter percentage (0-100) to avoid thundering herd";
                 };
             };
         };
         readonly retry_if: {
             readonly type: "object";
+            readonly description: "Conditional retry based on error or result";
             readonly properties: {
                 readonly expr: {
                     readonly type: "string";
+                    readonly description: "JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables";
                 };
             };
             readonly required: readonly ["expr"];
@@ -108,114 +161,150 @@ export declare const $Retry: {
 };
 export declare const $StopAfterIf: {
     readonly type: "object";
+    readonly description: "Early termination condition for a module";
     readonly properties: {
         readonly skip_if_stopped: {
             readonly type: "boolean";
+            readonly description: "If true, following steps are skipped when this condition triggers";
         };
         readonly expr: {
             readonly type: "string";
+            readonly description: "JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop";
         };
         readonly error_message: {
             readonly type: "string";
+            readonly description: "Custom error message shown when stopping";
         };
     };
     readonly required: readonly ["expr"];
 };
 export declare const $FlowModule: {
     readonly type: "object";
+    readonly description: "A single step in a flow. Can be a script, subflow, loop, or branch";
     readonly properties: {
         readonly id: {
             readonly type: "string";
+            readonly description: "Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)";
         };
         readonly value: {
             readonly $ref: "#/components/schemas/FlowModuleValue";
         };
         readonly stop_after_if: {
+            readonly description: "Early termination condition evaluated after this step completes";
             readonly $ref: "#/components/schemas/StopAfterIf";
         };
         readonly stop_after_all_iters_if: {
+            readonly description: "For loops only - early termination condition evaluated after all iterations complete";
             readonly $ref: "#/components/schemas/StopAfterIf";
         };
         readonly skip_if: {
             readonly type: "object";
+            readonly description: "Conditionally skip this step based on previous results or flow inputs";
             readonly properties: {
                 readonly expr: {
                     readonly type: "string";
+                    readonly description: "JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'";
                 };
             };
             readonly required: readonly ["expr"];
         };
         readonly sleep: {
+            readonly description: "Delay before executing this step (in seconds or as expression)";
             readonly $ref: "#/components/schemas/InputTransform";
         };
         readonly cache_ttl: {
             readonly type: "number";
+            readonly description: "Cache duration in seconds for this step's results";
+        };
+        readonly cache_ignore_s3_path: {
+            readonly type: "boolean";
         };
         readonly timeout: {
+            readonly description: "Maximum execution time in seconds (static value or expression)";
             readonly $ref: "#/components/schemas/InputTransform";
         };
         readonly delete_after_use: {
             readonly type: "boolean";
+            readonly description: "If true, this step's result is deleted after use to save memory";
         };
         readonly summary: {
             readonly type: "string";
+            readonly description: "Short description of what this step does";
         };
         readonly mock: {
             readonly type: "object";
+            readonly description: "Mock configuration for testing without executing the actual step";
             readonly properties: {
                 readonly enabled: {
                     readonly type: "boolean";
+                    readonly description: "If true, return mock value instead of executing";
+                };
+                readonly return_value: {
+                    readonly description: "Value to return when mocked";
                 };
-                readonly return_value: {};
             };
         };
         readonly suspend: {
             readonly type: "object";
+            readonly description: "Configuration for approval/resume steps that wait for user input";
             readonly properties: {
                 readonly required_events: {
                     readonly type: "integer";
+                    readonly description: "Number of approvals required before continuing";
                 };
                 readonly timeout: {
                     readonly type: "integer";
+                    readonly description: "Timeout in seconds before auto-continuing or canceling";
                 };
                 readonly resume_form: {
                     readonly type: "object";
+                    readonly description: "Form schema for collecting input when resuming";
                     readonly properties: {
                         readonly schema: {
                             readonly type: "object";
+                            readonly description: "JSON Schema for the resume form";
                         };
                     };
                 };
                 readonly user_auth_required: {
                     readonly type: "boolean";
+                    readonly description: "If true, only authenticated users can approve";
                 };
                 readonly user_groups_required: {
+                    readonly description: "Expression or list of groups that can approve";
                     readonly $ref: "#/components/schemas/InputTransform";
                 };
                 readonly self_approval_disabled: {
                     readonly type: "boolean";
+                    readonly description: "If true, the user who started the flow cannot approve";
                 };
                 readonly hide_cancel: {
                     readonly type: "boolean";
+                    readonly description: "If true, hide the cancel button on the approval form";
                 };
                 readonly continue_on_disapprove_timeout: {
                     readonly type: "boolean";
+                    readonly description: "If true, continue flow on timeout instead of canceling";
                 };
             };
         };
         readonly priority: {
             readonly type: "number";
+            readonly description: "Execution priority for this step (higher numbers run first)";
         };
         readonly continue_on_error: {
             readonly type: "boolean";
+            readonly description: "If true, flow continues even if this step fails";
         };
         readonly retry: {
+            readonly description: "Retry configuration if this step fails";
             readonly $ref: "#/components/schemas/Retry";
         };
     };
     readonly required: readonly ["value", "id"];
 };
 export declare const $InputTransform: {
+    readonly description: "Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs";
     readonly oneOf: readonly [{
         readonly $ref: "#/components/schemas/StaticTransform";
     }, {
@@ -231,20 +320,25 @@ export declare const $InputTransform: {
 };
 export declare const $StaticTransform: {
     readonly type: "object";
+    readonly description: "Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'";
     readonly properties: {
-        readonly value: {};
+        readonly value: {
+            readonly description: "The static value. For resources, use format '$res:path/to/resource'";
+        };
         readonly type: {
             readonly type: "string";
             readonly enum: readonly ["static"];
         };
     };
-    readonly required: readonly ["value", "type"];
+    readonly required: readonly ["type"];
 };
 export declare const $JavascriptTransform: {
     readonly type: "object";
+    readonly description: "JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value";
     readonly properties: {
         readonly expr: {
             readonly type: "string";
+            readonly description: "JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)";
         };
         readonly type: {
             readonly type: "string";
@@ -254,6 +348,7 @@ export declare const $JavascriptTransform: {
     readonly required: readonly ["expr", "type"];
 };
 export declare const $FlowModuleValue: {
+    readonly description: "The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type";
     readonly oneOf: readonly [{
         readonly $ref: "#/components/schemas/RawScript";
     }, {
@@ -290,25 +385,31 @@ export declare const $FlowModuleValue: {
 };
 export declare const $RawScript: {
     readonly type: "object";
+    readonly description: "Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms";
     readonly properties: {
         readonly input_transforms: {
             readonly type: "object";
+            readonly description: "Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments";
             readonly additionalProperties: {
                 readonly $ref: "#/components/schemas/InputTransform";
             };
         };
         readonly content: {
             readonly type: "string";
+            readonly description: "The script source code. Should export a 'main' function";
         };
         readonly language: {
             readonly type: "string";
+            readonly description: "Programming language for this script";
             readonly enum: readonly ["deno", "bun", "python3", "go", "bash", "powershell", "postgresql", "mysql", "bigquery", "snowflake", "mssql", "oracledb", "graphql", "nativets", "php"];
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "Optional path for saving this script";
         };
         readonly lock: {
             readonly type: "string";
+            readonly description: "Lock file content for dependencies";
         };
         readonly type: {
             readonly type: "string";
@@ -316,38 +417,48 @@ export declare const $RawScript: {
         };
         readonly tag: {
             readonly type: "string";
+            readonly description: "Worker group tag for execution routing";
         };
         readonly concurrent_limit: {
             readonly type: "number";
+            readonly description: "Maximum concurrent executions of this script";
         };
         readonly concurrency_time_window_s: {
             readonly type: "number";
+            readonly description: "Time window for concurrent_limit";
         };
         readonly custom_concurrency_key: {
             readonly type: "string";
+            readonly description: "Custom key for grouping concurrent executions";
         };
         readonly is_trigger: {
             readonly type: "boolean";
+            readonly description: "If true, this script is a trigger that can start the flow";
         };
         readonly assets: {
             readonly type: "array";
+            readonly description: "External resources this script accesses (S3 objects, resources, etc.)";
             readonly items: {
                 readonly type: "object";
                 readonly required: readonly ["path", "kind"];
                 readonly properties: {
                     readonly path: {
                         readonly type: "string";
+                        readonly description: "Path to the asset";
                     };
                     readonly kind: {
                         readonly type: "string";
-                        readonly enum: readonly ["s3object", "resource", "ducklake"];
+                        readonly description: "Type of asset";
+                        readonly enum: readonly ["s3object", "resource", "ducklake", "datatable"];
                     };
                     readonly access_type: {
                         readonly type: "string";
+                        readonly description: "Access level for this asset";
                         readonly enum: readonly ["r", "w", "rw"];
                     };
                     readonly alt_access_type: {
                         readonly type: "string";
+                        readonly description: "Alternative access level";
                         readonly enum: readonly ["r", "w", "rw"];
                     };
                 };
@@ -358,18 +469,22 @@ export declare const $RawScript: {
 };
 export declare const $PathScript: {
     readonly type: "object";
+    readonly description: "Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code";
     readonly properties: {
         readonly input_transforms: {
             readonly type: "object";
+            readonly description: "Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments";
             readonly additionalProperties: {
                 readonly $ref: "#/components/schemas/InputTransform";
             };
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "Path to the script in the workspace (e.g., 'f/scripts/send_email')";
         };
         readonly hash: {
             readonly type: "string";
+            readonly description: "Optional specific version hash of the script to use";
         };
         readonly type: {
             readonly type: "string";
@@ -377,24 +492,29 @@ export declare const $PathScript: {
         };
         readonly tag_override: {
             readonly type: "string";
+            readonly description: "Override the script's default worker group tag";
         };
         readonly is_trigger: {
             readonly type: "boolean";
+            readonly description: "If true, this script is a trigger that can start the flow";
         };
     };
     readonly required: readonly ["type", "path", "input_transforms"];
 };
 export declare const $PathFlow: {
     readonly type: "object";
+    readonly description: "Reference to an existing flow by path. Use this to call another flow as a subflow";
     readonly properties: {
         readonly input_transforms: {
             readonly type: "object";
+            readonly description: "Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments";
             readonly additionalProperties: {
                 readonly $ref: "#/components/schemas/InputTransform";
             };
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "Path to the flow in the workspace (e.g., 'f/flows/process_user')";
         };
         readonly type: {
             readonly type: "string";
@@ -405,18 +525,22 @@ export declare const $PathFlow: {
 };
 export declare const $ForloopFlow: {
     readonly type: "object";
+    readonly description: "Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations";
     readonly properties: {
         readonly modules: {
             readonly type: "array";
+            readonly description: "Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'";
             readonly items: {
                 readonly $ref: "#/components/schemas/FlowModule";
             };
         };
         readonly iterator: {
+            readonly description: "JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'";
             readonly $ref: "#/components/schemas/InputTransform";
         };
         readonly skip_failures: {
             readonly type: "boolean";
+            readonly description: "If true, iteration failures don't stop the loop. Failed iterations return null";
         };
         readonly type: {
             readonly type: "string";
@@ -424,24 +548,32 @@ export declare const $ForloopFlow: {
         };
         readonly parallel: {
             readonly type: "boolean";
+            readonly description: "If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency";
         };
         readonly parallelism: {
+            readonly description: "Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression";
             readonly $ref: "#/components/schemas/InputTransform";
         };
+        readonly squash: {
+            readonly type: "boolean";
+        };
     };
     readonly required: readonly ["modules", "iterator", "skip_failures", "type"];
 };
 export declare const $WhileloopFlow: {
     readonly type: "object";
+    readonly description: "Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination";
     readonly properties: {
         readonly modules: {
             readonly type: "array";
+            readonly description: "Steps to execute in each iteration. Use stop_after_if to control when the loop ends";
             readonly items: {
                 readonly $ref: "#/components/schemas/FlowModule";
             };
         };
         readonly skip_failures: {
             readonly type: "boolean";
+            readonly description: "If true, iteration failures don't stop the loop. Failed iterations return null";
         };
         readonly type: {
             readonly type: "string";
@@ -449,29 +581,39 @@ export declare const $WhileloopFlow: {
         };
         readonly parallel: {
             readonly type: "boolean";
+            readonly description: "If true, iterations run concurrently (use with caution in while loops)";
         };
         readonly parallelism: {
+            readonly description: "Maximum number of concurrent iterations when parallel=true";
             readonly $ref: "#/components/schemas/InputTransform";
         };
+        readonly squash: {
+            readonly type: "boolean";
+        };
     };
     readonly required: readonly ["modules", "skip_failures", "type"];
 };
 export declare const $BranchOne: {
     readonly type: "object";
+    readonly description: "Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes";
     readonly properties: {
         readonly branches: {
             readonly type: "array";
+            readonly description: "Array of branches to evaluate in order. The first branch with expr evaluating to true executes";
             readonly items: {
                 readonly type: "object";
                 readonly properties: {
                     readonly summary: {
                         readonly type: "string";
+                        readonly description: "Short description of this branch condition";
                     };
                     readonly expr: {
                         readonly type: "string";
+                        readonly description: "JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins";
                     };
                     readonly modules: {
                         readonly type: "array";
+                        readonly description: "Steps to execute if this branch's expr is true";
                         readonly items: {
                             readonly $ref: "#/components/schemas/FlowModule";
                         };
@@ -482,10 +624,10 @@ export declare const $BranchOne: {
         };
         readonly default: {
             readonly type: "array";
+            readonly description: "Steps to execute if no branch expressions match";
             readonly items: {
                 readonly $ref: "#/components/schemas/FlowModule";
             };
-            readonly required: readonly ["modules"];
         };
         readonly type: {
             readonly type: "string";
@@ -496,20 +638,25 @@ export declare const $BranchOne: {
 };
 export declare const $BranchAll: {
     readonly type: "object";
+    readonly description: "Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently";
     readonly properties: {
         readonly branches: {
             readonly type: "array";
+            readonly description: "Array of branches that all execute (either in parallel or sequentially)";
             readonly items: {
                 readonly type: "object";
                 readonly properties: {
                     readonly summary: {
                         readonly type: "string";
+                        readonly description: "Short description of this branch's purpose";
                     };
                     readonly skip_failure: {
                         readonly type: "boolean";
+                        readonly description: "If true, failure in this branch doesn't fail the entire flow";
                     };
                     readonly modules: {
                         readonly type: "array";
+                        readonly description: "Steps to execute in this branch";
                         readonly items: {
                             readonly $ref: "#/components/schemas/FlowModule";
                         };
@@ -524,23 +671,133 @@ export declare const $BranchAll: {
         };
         readonly parallel: {
             readonly type: "boolean";
+            readonly description: "If true, all branches execute concurrently. If false, they execute sequentially";
         };
     };
     readonly required: readonly ["branches", "type"];
 };
 export declare const $AiAgent: {
     readonly type: "object";
+    readonly description: "AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task";
     readonly properties: {
         readonly input_transforms: {
             readonly type: "object";
-            readonly additionalProperties: {
-                readonly $ref: "#/components/schemas/InputTransform";
+            readonly description: "Input parameters for the AI agent mapped to their values";
+            readonly properties: {
+                readonly provider: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
+                readonly output_type: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
+                readonly user_message: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
+                readonly system_prompt: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
+                readonly streaming: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
+                readonly memory: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
+                readonly output_schema: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
+                readonly user_images: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
+                readonly max_completion_tokens: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
+                readonly temperature: {
+                    readonly $ref: "#/components/schemas/InputTransform";
+                };
             };
+            readonly required: readonly ["provider", "user_message", "output_type"];
         };
         readonly tools: {
             readonly type: "array";
+            readonly description: "Array of tools the agent can use. The agent decides which tools to call based on the task";
             readonly items: {
-                readonly $ref: "#/components/schemas/FlowModule";
+                readonly type: "object";
+                readonly description: "A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool";
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly description: "Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')";
+                    };
+                    readonly summary: {
+                        readonly type: "string";
+                        readonly description: "Short description of what this tool does (shown to the AI)";
+                    };
+                    readonly value: {
+                        readonly description: "The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference";
+                        readonly oneOf: readonly [{
+                            readonly description: "A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module";
+                            readonly allOf: readonly [{
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly tool_type: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["flowmodule"];
+                                    };
+                                };
+                                readonly required: readonly ["tool_type"];
+                            }, {
+                                readonly $ref: "#/components/schemas/FlowModuleValue";
+                            }];
+                        }, {
+                            readonly type: "object";
+                            readonly description: "Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers";
+                            readonly properties: {
+                                readonly tool_type: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["mcp"];
+                                };
+                                readonly resource_path: {
+                                    readonly type: "string";
+                                    readonly description: "Path to the MCP resource/server configuration";
+                                };
+                                readonly include_tools: {
+                                    readonly type: "array";
+                                    readonly description: "Whitelist of specific tools to include from this MCP server";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly exclude_tools: {
+                                    readonly type: "array";
+                                    readonly description: "Blacklist of tools to exclude from this MCP server";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly required: readonly ["tool_type", "resource_path"];
+                        }, {
+                            readonly type: "object";
+                            readonly description: "A tool implemented as a websearch tool. The AI can call this like any other websearch tool";
+                            readonly properties: {
+                                readonly tool_type: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["websearch"];
+                                };
+                            };
+                            readonly required: readonly ["tool_type"];
+                        }];
+                        readonly discriminator: {
+                            readonly propertyName: "tool_type";
+                            readonly mapping: {
+                                readonly flowmodule: "#/components/schemas/FlowModuleTool";
+                                readonly mcp: "#/components/schemas/McpToolValue";
+                                readonly websearch: "#/components/schemas/WebsearchToolValue";
+                            };
+                        };
+                    };
+                };
+                readonly required: readonly ["id", "value"];
             };
         };
         readonly type: {
@@ -549,12 +806,14 @@ export declare const $AiAgent: {
         };
         readonly parallel: {
             readonly type: "boolean";
+            readonly description: "If true, the agent can execute multiple tool calls in parallel";
         };
     };
     readonly required: readonly ["tools", "type", "input_transforms"];
 };
 export declare const $Identity: {
     readonly type: "object";
+    readonly description: "Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder";
     readonly properties: {
         readonly type: {
             readonly type: "string";
@@ -562,6 +821,7 @@ export declare const $Identity: {
         };
         readonly flow: {
             readonly type: "boolean";
+            readonly description: "If true, marks this as a flow identity (special handling)";
         };
     };
     readonly required: readonly ["type"];
@@ -646,6 +906,9 @@ export declare const $FlowStatusModule: {
                     readonly type: "array";
                     readonly items: {};
                 };
+                readonly itered_len: {
+                    readonly type: "integer";
+                };
                 readonly args: {};
             };
         };
@@ -751,6 +1014,37 @@ export declare const $FlowStatusModule: {
                         };
                     };
                     readonly required: readonly ["job_id", "function_name", "type", "module_id"];
+                }, {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly call_id: {
+                            readonly type: "string";
+                            readonly format: "uuid";
+                        };
+                        readonly function_name: {
+                            readonly type: "string";
+                        };
+                        readonly resource_path: {
+                            readonly type: "string";
+                        };
+                        readonly type: {
+                            readonly type: "string";
+                            readonly enum: readonly ["mcp_tool_call"];
+                        };
+                        readonly arguments: {
+                            readonly type: "object";
+                        };
+                    };
+                    readonly required: readonly ["call_id", "function_name", "resource_path", "type"];
+                }, {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly enum: readonly ["web_search"];
+                        };
+                    };
+                    readonly required: readonly ["type"];
                 }, {
                     readonly type: "object";
                     readonly properties: {
@@ -772,6 +1066,72 @@ export declare const $FlowStatusModule: {
     };
     readonly required: readonly ["type"];
 };
+export declare const $FlowNote: {
+    readonly type: "object";
+    readonly description: "A sticky note attached to a flow for documentation and annotation";
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+            readonly description: "Unique identifier for the note";
+        };
+        readonly text: {
+            readonly type: "string";
+            readonly description: "Content of the note";
+        };
+        readonly position: {
+            readonly type: "object";
+            readonly description: "Position of the note in the flow editor";
+            readonly properties: {
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "X coordinate";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "Y coordinate";
+                };
+            };
+            readonly required: readonly ["x", "y"];
+        };
+        readonly size: {
+            readonly type: "object";
+            readonly description: "Size of the note in the flow editor";
+            readonly properties: {
+                readonly width: {
+                    readonly type: "number";
+                    readonly description: "Width in pixels";
+                };
+                readonly height: {
+                    readonly type: "number";
+                    readonly description: "Height in pixels";
+                };
+            };
+            readonly required: readonly ["width", "height"];
+        };
+        readonly color: {
+            readonly type: "string";
+            readonly description: "Color of the note (e.g., \"yellow\", \"#ffff00\")";
+        };
+        readonly type: {
+            readonly type: "string";
+            readonly enum: readonly ["free", "group"];
+            readonly description: "Type of note - 'free' for standalone notes, 'group' for notes that group other nodes";
+        };
+        readonly locked: {
+            readonly type: "boolean";
+            readonly default: false;
+            readonly description: "Whether the note is locked and cannot be edited or moved";
+        };
+        readonly contained_node_ids: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "For group notes, the IDs of nodes contained within this group";
+        };
+    };
+    readonly required: readonly ["id", "text", "color", "type"];
+};
 export declare const $FlowConversation: {
     readonly type: "object";
     readonly required: readonly ["id", "workspace_id", "flow_path", "created_at", "updated_at", "created_by"];
@@ -897,7 +1257,7 @@ export declare const $EndpointTool: {
 };
 export declare const $AIProvider: {
     readonly type: "string";
-    readonly enum: readonly ["openai", "azure_openai", "anthropic", "mistral", "deepseek", "googleai", "groq", "openrouter", "togetherai", "customai"];
+    readonly enum: readonly ["openai", "azure_openai", "anthropic", "mistral", "deepseek", "googleai", "groq", "openrouter", "togetherai", "aws_bedrock", "customai"];
 };
 export declare const $GitSyncObjectType: {
     readonly type: "string";
@@ -997,6 +1357,58 @@ export declare const $Configs: {
         };
     };
 };
+export declare const $WorkspaceDependencies: {
+    readonly type: "object";
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+        };
+        readonly archived: {
+            readonly type: "boolean";
+        };
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+        };
+        readonly content: {
+            readonly type: "string";
+        };
+        readonly language: {
+            readonly $ref: "#/components/schemas/ScriptLang";
+        };
+        readonly workspace_id: {
+            readonly type: "string";
+        };
+        readonly created_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+    };
+    readonly required: readonly ["workspace_id", "language", "created_at", "content", "id", "archived"];
+};
+export declare const $NewWorkspaceDependencies: {
+    readonly type: "object";
+    readonly properties: {
+        readonly workspace_id: {
+            readonly type: "string";
+        };
+        readonly language: {
+            readonly $ref: "#/components/schemas/ScriptLang";
+        };
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+        };
+        readonly content: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["workspace_id", "language", "content"];
+};
 export declare const $Script: {
     readonly type: "object";
     readonly properties: {
@@ -1090,6 +1502,12 @@ export declare const $Script: {
         readonly concurrency_key: {
             readonly type: "string";
         };
+        readonly debounce_key: {
+            readonly type: "string";
+        };
+        readonly debounce_delay_s: {
+            readonly type: "integer";
+        };
         readonly cache_ttl: {
             readonly type: "number";
         };
@@ -1184,6 +1602,9 @@ export declare const $NewScript: {
         readonly cache_ttl: {
             readonly type: "number";
         };
+        readonly cache_ignore_s3_path: {
+            readonly type: "boolean";
+        };
         readonly dedicated_worker: {
             readonly type: "boolean";
         };
@@ -1208,6 +1629,12 @@ export declare const $NewScript: {
         readonly concurrency_key: {
             readonly type: "string";
         };
+        readonly debounce_key: {
+            readonly type: "string";
+        };
+        readonly debounce_delay_s: {
+            readonly type: "integer";
+        };
         readonly visible_to_runner_only: {
             readonly type: "boolean";
         };
@@ -1400,7 +1827,7 @@ export declare const $QueuedJob: {
         };
         readonly job_kind: {
             readonly type: "string";
-            readonly enum: readonly ["script", "preview", "dependencies", "flowdependencies", "appdependencies", "flow", "flowpreview", "script_hub", "identity", "deploymentcallback", "singlestepflow", "flowscript", "flownode", "appscript", "aiagent"];
+            readonly enum: readonly ["script", "preview", "dependencies", "flowdependencies", "appdependencies", "flow", "flowpreview", "script_hub", "identity", "deploymentcallback", "singlestepflow", "flowscript", "flownode", "appscript", "aiagent", "unassigned_script", "unassigned_flow", "unassigned_singlestepflow"];
         };
         readonly schedule_path: {
             readonly type: "string";
@@ -1482,6 +1909,10 @@ export declare const $CompletedJob: {
             readonly type: "string";
             readonly format: "date-time";
         };
+        readonly completed_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
         readonly duration_ms: {
             readonly type: "integer";
         };
@@ -1495,20 +1926,297 @@ export declare const $CompletedJob: {
             readonly type: "string";
         };
         readonly args: {
-            readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly $ref: "#/components/schemas/ScriptArgs";
+        };
+        readonly result: {};
+        readonly logs: {
+            readonly type: "string";
+        };
+        readonly deleted: {
+            readonly type: "boolean";
+        };
+        readonly raw_code: {
+            readonly type: "string";
+        };
+        readonly canceled: {
+            readonly type: "boolean";
+        };
+        readonly canceled_by: {
+            readonly type: "string";
+        };
+        readonly canceled_reason: {
+            readonly type: "string";
+        };
+        readonly job_kind: {
+            readonly type: "string";
+            readonly enum: readonly ["script", "preview", "dependencies", "flow", "flowdependencies", "appdependencies", "flowpreview", "script_hub", "identity", "deploymentcallback", "singlestepflow", "flowscript", "flownode", "appscript", "aiagent", "unassigned_script", "unassigned_flow", "unassigned_singlestepflow"];
+        };
+        readonly schedule_path: {
+            readonly type: "string";
+        };
+        readonly permissioned_as: {
+            readonly type: "string";
+            readonly description: "The user (u/userfoo) or group (g/groupfoo) whom\nthe execution of this script will be permissioned_as and by extension its DT_TOKEN.\n";
+        };
+        readonly flow_status: {
+            readonly $ref: "#/components/schemas/FlowStatus";
+        };
+        readonly workflow_as_code_status: {
+            readonly $ref: "#/components/schemas/WorkflowStatus";
+        };
+        readonly raw_flow: {
+            readonly $ref: "#/components/schemas/FlowValue";
+        };
+        readonly is_flow_step: {
+            readonly type: "boolean";
+        };
+        readonly language: {
+            readonly $ref: "#/components/schemas/ScriptLang";
+        };
+        readonly is_skipped: {
+            readonly type: "boolean";
+        };
+        readonly email: {
+            readonly type: "string";
+        };
+        readonly visible_to_owner: {
+            readonly type: "boolean";
+        };
+        readonly mem_peak: {
+            readonly type: "integer";
+        };
+        readonly tag: {
+            readonly type: "string";
+        };
+        readonly priority: {
+            readonly type: "integer";
+        };
+        readonly labels: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly self_wait_time_ms: {
+            readonly type: "number";
+        };
+        readonly aggregate_wait_time_ms: {
+            readonly type: "number";
+        };
+        readonly preprocessed: {
+            readonly type: "boolean";
+        };
+        readonly worker: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["id", "created_by", "duration_ms", "created_at", "started_at", "success", "canceled", "job_kind", "permissioned_as", "is_flow_step", "is_skipped", "email", "visible_to_owner", "tag"];
+};
+export declare const $ExportableCompletedJob: {
+    readonly type: "object";
+    readonly description: "Completed job with full data for export/import operations";
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+            readonly format: "uuid";
+        };
+        readonly parent_job: {
+            readonly type: "string";
+            readonly format: "uuid";
+        };
+        readonly created_by: {
+            readonly type: "string";
+        };
+        readonly created_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly started_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly completed_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly duration_ms: {
+            readonly type: "integer";
+        };
+        readonly script_path: {
+            readonly type: "string";
+        };
+        readonly script_hash: {
+            readonly type: "string";
+        };
+        readonly args: {
+            readonly type: "object";
+            readonly description: "Full job arguments without size restrictions";
+        };
+        readonly result: {
+            readonly type: "object";
+            readonly description: "Full job result without size restrictions";
+        };
+        readonly logs: {
+            readonly type: "string";
+            readonly description: "Complete job logs from v2_job table";
+        };
+        readonly raw_code: {
+            readonly type: "string";
+        };
+        readonly raw_lock: {
+            readonly type: "string";
+        };
+        readonly canceled_by: {
+            readonly type: "string";
+        };
+        readonly canceled_reason: {
+            readonly type: "string";
+        };
+        readonly job_kind: {
+            readonly type: "string";
+            readonly enum: readonly ["script", "preview", "dependencies", "flow", "flowdependencies", "appdependencies", "flowpreview", "script_hub", "identity", "deploymentcallback", "singlestepflow", "flowscript", "flownode", "appscript", "aiagent", "unassigned_script", "unassigned_flow", "unassigned_singlestepflow"];
+        };
+        readonly trigger: {
+            readonly type: "string";
+            readonly description: "Trigger path for the job (replaces schedule_path)";
+        };
+        readonly trigger_kind: {
+            readonly type: "string";
+            readonly enum: readonly ["webhook", "http", "websocket", "kafka", "email", "nats", "schedule", "app", "ui", "postgres", "sqs", "gcp"];
+        };
+        readonly permissioned_as: {
+            readonly type: "string";
+        };
+        readonly permissioned_as_email: {
+            readonly type: "string";
+        };
+        readonly flow_status: {
+            readonly type: "object";
+            readonly description: "Flow status from v2_job_status table";
+        };
+        readonly workflow_as_code_status: {
+            readonly type: "object";
+        };
+        readonly raw_flow: {
+            readonly type: "object";
+        };
+        readonly is_flow_step: {
+            readonly type: "boolean";
+        };
+        readonly language: {
+            readonly $ref: "#/components/schemas/ScriptLang";
+        };
+        readonly is_skipped: {
+            readonly type: "boolean";
+        };
+        readonly email: {
+            readonly type: "string";
+        };
+        readonly visible_to_owner: {
+            readonly type: "boolean";
+        };
+        readonly mem_peak: {
+            readonly type: "integer";
+        };
+        readonly tag: {
+            readonly type: "string";
+        };
+        readonly priority: {
+            readonly type: "integer";
+        };
+        readonly labels: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly same_worker: {
+            readonly type: "boolean";
+        };
+        readonly flow_step_id: {
+            readonly type: "string";
+        };
+        readonly flow_innermost_root_job: {
+            readonly type: "string";
+            readonly format: "uuid";
+        };
+        readonly concurrent_limit: {
+            readonly type: "integer";
+        };
+        readonly concurrency_time_window_s: {
+            readonly type: "integer";
+        };
+        readonly timeout: {
+            readonly type: "integer";
+        };
+        readonly cache_ttl: {
+            readonly type: "integer";
+        };
+        readonly self_wait_time_ms: {
+            readonly type: "integer";
+        };
+        readonly aggregate_wait_time_ms: {
+            readonly type: "integer";
+        };
+        readonly preprocessed: {
+            readonly type: "boolean";
+        };
+        readonly worker: {
+            readonly type: "string";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly description: "Actual job status from database";
+        };
+    };
+    readonly required: readonly ["id", "created_by", "created_at", "job_kind", "permissioned_as", "email", "visible_to_owner"];
+};
+export declare const $ExportableQueuedJob: {
+    readonly type: "object";
+    readonly description: "Queued job with full data for export/import operations";
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+            readonly format: "uuid";
+        };
+        readonly parent_job: {
+            readonly type: "string";
+            readonly format: "uuid";
+        };
+        readonly created_by: {
+            readonly type: "string";
+        };
+        readonly created_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly started_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly scheduled_for: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly script_path: {
+            readonly type: "string";
+        };
+        readonly script_hash: {
+            readonly type: "string";
+        };
+        readonly args: {
+            readonly type: "object";
+            readonly description: "Full job arguments without size restrictions";
         };
-        readonly result: {};
         readonly logs: {
             readonly type: "string";
-        };
-        readonly deleted: {
-            readonly type: "boolean";
+            readonly description: "Complete job logs from v2_job table";
         };
         readonly raw_code: {
             readonly type: "string";
         };
-        readonly canceled: {
-            readonly type: "boolean";
+        readonly raw_lock: {
+            readonly type: "string";
         };
         readonly canceled_by: {
             readonly type: "string";
@@ -1518,23 +2226,31 @@ export declare const $CompletedJob: {
         };
         readonly job_kind: {
             readonly type: "string";
-            readonly enum: readonly ["script", "preview", "dependencies", "flow", "flowdependencies", "appdependencies", "flowpreview", "script_hub", "identity", "deploymentcallback", "singlestepflow", "flowscript", "flownode", "appscript", "aiagent"];
+            readonly enum: readonly ["script", "preview", "dependencies", "flowdependencies", "appdependencies", "flow", "flowpreview", "script_hub", "identity", "deploymentcallback", "singlestepflow", "flowscript", "flownode", "appscript", "aiagent", "unassigned_script", "unassigned_flow", "unassigned_singlestepflow"];
         };
-        readonly schedule_path: {
+        readonly trigger: {
+            readonly type: "string";
+            readonly description: "Trigger path for the job (replaces schedule_path)";
+        };
+        readonly trigger_kind: {
             readonly type: "string";
+            readonly enum: readonly ["webhook", "http", "websocket", "kafka", "email", "nats", "schedule", "app", "ui", "postgres", "sqs", "gcp"];
         };
         readonly permissioned_as: {
             readonly type: "string";
-            readonly description: "The user (u/userfoo) or group (g/groupfoo) whom\nthe execution of this script will be permissioned_as and by extension its DT_TOKEN.\n";
+        };
+        readonly permissioned_as_email: {
+            readonly type: "string";
         };
         readonly flow_status: {
-            readonly $ref: "#/components/schemas/FlowStatus";
+            readonly type: "object";
+            readonly description: "Flow status from v2_job_status table";
         };
         readonly workflow_as_code_status: {
-            readonly $ref: "#/components/schemas/WorkflowStatus";
+            readonly type: "object";
         };
         readonly raw_flow: {
-            readonly $ref: "#/components/schemas/FlowValue";
+            readonly type: "object";
         };
         readonly is_flow_step: {
             readonly type: "boolean";
@@ -1542,9 +2258,6 @@ export declare const $CompletedJob: {
         readonly language: {
             readonly $ref: "#/components/schemas/ScriptLang";
         };
-        readonly is_skipped: {
-            readonly type: "boolean";
-        };
         readonly email: {
             readonly type: "string";
         };
@@ -1566,20 +2279,46 @@ export declare const $CompletedJob: {
                 readonly type: "string";
             };
         };
+        readonly same_worker: {
+            readonly type: "boolean";
+        };
+        readonly flow_step_id: {
+            readonly type: "string";
+        };
+        readonly flow_innermost_root_job: {
+            readonly type: "string";
+            readonly format: "uuid";
+        };
+        readonly concurrent_limit: {
+            readonly type: "integer";
+        };
+        readonly concurrency_time_window_s: {
+            readonly type: "integer";
+        };
+        readonly timeout: {
+            readonly type: "integer";
+        };
+        readonly cache_ttl: {
+            readonly type: "integer";
+        };
         readonly self_wait_time_ms: {
-            readonly type: "number";
+            readonly type: "integer";
         };
         readonly aggregate_wait_time_ms: {
-            readonly type: "number";
+            readonly type: "integer";
         };
         readonly preprocessed: {
             readonly type: "boolean";
         };
-        readonly worker: {
+        readonly suspend: {
+            readonly type: "integer";
+        };
+        readonly suspend_until: {
             readonly type: "string";
+            readonly format: "date-time";
         };
     };
-    readonly required: readonly ["id", "created_by", "duration_ms", "created_at", "started_at", "success", "canceled", "job_kind", "permissioned_as", "is_flow_step", "is_skipped", "email", "visible_to_owner", "tag"];
+    readonly required: readonly ["id", "created_by", "created_at", "job_kind", "permissioned_as", "email", "visible_to_owner"];
 };
 export declare const $ObscuredJob: {
     readonly type: "object";
@@ -2135,6 +2874,22 @@ export declare const $Preview: {
     };
     readonly required: readonly ["args"];
 };
+export declare const $PreviewInline: {
+    readonly type: "object";
+    readonly properties: {
+        readonly content: {
+            readonly type: "string";
+            readonly description: "The code to run";
+        };
+        readonly args: {
+            readonly $ref: "#/components/schemas/ScriptArgs";
+        };
+        readonly language: {
+            readonly $ref: "#/components/schemas/ScriptLang";
+        };
+    };
+    readonly required: readonly ["content", "args", "language"];
+};
 export declare const $WorkflowTask: {
     readonly type: "object";
     readonly properties: {
@@ -2657,6 +3412,16 @@ export declare const $EditSchedule: {
     };
     readonly required: readonly ["schedule", "timezone", "args"];
 };
+export declare const $JobTriggerKind: {
+    readonly description: "job trigger kind (schedule, http, websocket...)";
+    readonly type: "string";
+    readonly enum: readonly ["webhook", "default_email", "email", "schedule", "http", "websocket", "postgres", "kafka", "nats", "mqtt", "sqs", "gcp"];
+};
+export declare const $TriggerMode: {
+    readonly description: "job trigger mode";
+    readonly type: "string";
+    readonly enum: readonly ["enabled", "disabled", "suspended"];
+};
 export declare const $TriggerExtraProperty: {
     readonly type: "object";
     readonly properties: {
@@ -2688,8 +3453,11 @@ export declare const $TriggerExtraProperty: {
         readonly is_flow: {
             readonly type: "boolean";
         };
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
+        };
     };
-    readonly required: readonly ["path", "script_path", "email", "extra_perms", "workspace_id", "edited_by", "edited_at", "is_flow"];
+    readonly required: readonly ["path", "script_path", "email", "extra_perms", "workspace_id", "edited_by", "edited_at", "is_flow", "mode"];
 };
 export declare const $AuthenticationMethod: {
     readonly type: "string";
@@ -2814,6 +3582,10 @@ export declare const $HttpMethod: {
     readonly type: "string";
     readonly enum: readonly ["get", "post", "put", "delete", "patch"];
 };
+export declare const $HttpRequestType: {
+    readonly type: "string";
+    readonly enum: readonly ["sync", "async", "sync_sse"];
+};
 export declare const $HttpTrigger: {
     readonly allOf: readonly [{
         readonly $ref: "#/components/schemas/TriggerExtraProperty";
@@ -2850,8 +3622,8 @@ export declare const $HttpTrigger: {
         readonly description: {
             readonly type: "string";
         };
-        readonly is_async: {
-            readonly type: "boolean";
+        readonly request_type: {
+            readonly $ref: "#/components/schemas/HttpRequestType";
         };
         readonly authentication_method: {
             readonly $ref: "#/components/schemas/AuthenticationMethod";
@@ -2878,7 +3650,7 @@ export declare const $HttpTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["route_path", "is_async", "authentication_method", "http_method", "is_static_website", "workspaced_route", "wrap_body", "raw_string"];
+    readonly required: readonly ["route_path", "request_type", "authentication_method", "http_method", "is_static_website", "workspaced_route", "wrap_body", "raw_string"];
 };
 export declare const $NewHttpTrigger: {
     readonly type: "object";
@@ -2927,6 +3699,10 @@ export declare const $NewHttpTrigger: {
         };
         readonly is_async: {
             readonly type: "boolean";
+            readonly description: "Deprecated, use request_type instead";
+        };
+        readonly request_type: {
+            readonly $ref: "#/components/schemas/HttpRequestType";
         };
         readonly authentication_method: {
             readonly $ref: "#/components/schemas/AuthenticationMethod";
@@ -2937,6 +3713,9 @@ export declare const $NewHttpTrigger: {
         readonly wrap_body: {
             readonly type: "boolean";
         };
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
+        };
         readonly raw_string: {
             readonly type: "boolean";
         };
@@ -2950,7 +3729,7 @@ export declare const $NewHttpTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["path", "script_path", "route_path", "is_flow", "is_async", "authentication_method", "http_method", "is_static_website"];
+    readonly required: readonly ["path", "script_path", "route_path", "is_flow", "authentication_method", "http_method", "is_static_website"];
 };
 export declare const $EditHttpTrigger: {
     readonly type: "object";
@@ -2999,6 +3778,10 @@ export declare const $EditHttpTrigger: {
         };
         readonly is_async: {
             readonly type: "boolean";
+            readonly description: "Deprecated, use request_type instead";
+        };
+        readonly request_type: {
+            readonly $ref: "#/components/schemas/HttpRequestType";
         };
         readonly authentication_method: {
             readonly $ref: "#/components/schemas/AuthenticationMethod";
@@ -3022,7 +3805,7 @@ export declare const $EditHttpTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["path", "script_path", "is_flow", "kind", "is_async", "authentication_method", "http_method", "is_static_website"];
+    readonly required: readonly ["path", "script_path", "is_flow", "kind", "authentication_method", "http_method", "is_static_website"];
 };
 export declare const $TriggersCount: {
     readonly type: "object";
@@ -3092,9 +3875,6 @@ export declare const $WebsocketTrigger: {
         readonly error: {
             readonly type: "string";
         };
-        readonly enabled: {
-            readonly type: "boolean";
-        };
         readonly filters: {
             readonly type: "array";
             readonly items: {
@@ -3133,7 +3913,7 @@ export declare const $WebsocketTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["url", "enabled", "filters", "can_return_message", "can_return_error_result"];
+    readonly required: readonly ["url", "filters", "can_return_message", "can_return_error_result"];
 };
 export declare const $NewWebsocketTrigger: {
     readonly type: "object";
@@ -3150,8 +3930,8 @@ export declare const $NewWebsocketTrigger: {
         readonly url: {
             readonly type: "string";
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly filters: {
             readonly type: "array";
@@ -3358,9 +4138,6 @@ export declare const $MqttTrigger: {
         readonly error: {
             readonly type: "string";
         };
-        readonly enabled: {
-            readonly type: "boolean";
-        };
         readonly error_handler_path: {
             readonly type: "string";
         };
@@ -3371,7 +4148,7 @@ export declare const $MqttTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["enabled", "subscribe_topics", "mqtt_resource_path"];
+    readonly required: readonly ["subscribe_topics", "mqtt_resource_path"];
 };
 export declare const $NewMqttTrigger: {
     readonly type: "object";
@@ -3406,8 +4183,8 @@ export declare const $NewMqttTrigger: {
         readonly is_flow: {
             readonly type: "boolean";
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
@@ -3454,8 +4231,8 @@ export declare const $EditMqttTrigger: {
         readonly is_flow: {
             readonly type: "boolean";
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
@@ -3519,9 +4296,6 @@ export declare const $GcpTrigger: {
         readonly error: {
             readonly type: "string";
         };
-        readonly enabled: {
-            readonly type: "boolean";
-        };
         readonly error_handler_path: {
             readonly type: "string";
         };
@@ -3532,7 +4306,7 @@ export declare const $GcpTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["gcp_resource_path", "topic_id", "subscription_id", "enabled", "delivery_type", "subscription_mode"];
+    readonly required: readonly ["gcp_resource_path", "topic_id", "subscription_id", "delivery_type", "subscription_mode"];
 };
 export declare const $SubscriptionMode: {
     readonly type: "string";
@@ -3572,8 +4346,8 @@ export declare const $GcpTriggerData: {
         readonly is_flow: {
             readonly type: "boolean";
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly auto_acknowledge_msg: {
             readonly type: "boolean";
@@ -3650,9 +4424,6 @@ export declare const $SqsTrigger: {
         readonly error: {
             readonly type: "string";
         };
-        readonly enabled: {
-            readonly type: "boolean";
-        };
         readonly error_handler_path: {
             readonly type: "string";
         };
@@ -3663,13 +4434,13 @@ export declare const $SqsTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["queue_url", "aws_resource_path", "enabled", "aws_auth_resource_type"];
+    readonly required: readonly ["queue_url", "aws_resource_path", "aws_auth_resource_type"];
 };
 export declare const $LoggedWizardStatus: {
     readonly type: "string";
     readonly enum: readonly ["OK", "SKIP", "FAIL"];
 };
-export declare const $DucklakeInstanceCatalogDbStatusLogs: {
+export declare const $CustomInstanceDbLogs: {
     readonly type: "object";
     readonly properties: {
         readonly super_admin: {
@@ -3683,7 +4454,6 @@ export declare const $DucklakeInstanceCatalogDbStatusLogs: {
         };
         readonly created_database: {
             readonly $ref: "#/components/schemas/LoggedWizardStatus";
-            readonly description: "Created database status log";
         };
         readonly db_connect: {
             readonly $ref: "#/components/schemas/LoggedWizardStatus";
@@ -3693,12 +4463,16 @@ export declare const $DucklakeInstanceCatalogDbStatusLogs: {
         };
     };
 };
-export declare const $DucklakeInstanceCatalogDbStatus: {
+export declare const $CustomInstanceDbTag: {
+    readonly type: "string";
+    readonly enum: readonly ["ducklake", "datatable"];
+};
+export declare const $CustomInstanceDb: {
     readonly type: "object";
     readonly required: readonly ["logs", "success"];
     readonly properties: {
         readonly logs: {
-            readonly $ref: "#/components/schemas/DucklakeInstanceCatalogDbStatusLogs";
+            readonly $ref: "#/components/schemas/CustomInstanceDbLogs";
         };
         readonly success: {
             readonly type: "boolean";
@@ -3711,6 +4485,9 @@ export declare const $DucklakeInstanceCatalogDbStatus: {
             readonly description: "Error message if the operation failed";
             readonly example: "Connection timeout";
         };
+        readonly tag: {
+            readonly $ref: "#/components/schemas/CustomInstanceDbTag";
+        };
     };
 };
 export declare const $NewSqsTrigger: {
@@ -3740,8 +4517,8 @@ export declare const $NewSqsTrigger: {
         readonly is_flow: {
             readonly type: "boolean";
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
@@ -3782,8 +4559,8 @@ export declare const $EditSqsTrigger: {
         readonly is_flow: {
             readonly type: "boolean";
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
@@ -3895,9 +4672,6 @@ export declare const $PostgresTrigger: {
     }];
     readonly type: "object";
     readonly properties: {
-        readonly enabled: {
-            readonly type: "boolean";
-        };
         readonly postgres_resource_path: {
             readonly type: "string";
         };
@@ -3927,7 +4701,7 @@ export declare const $PostgresTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["enabled", "postgres_resource_path", "replication_slot_name", "publication_name"];
+    readonly required: readonly ["postgres_resource_path", "replication_slot_name", "publication_name"];
 };
 export declare const $NewPostgresTrigger: {
     readonly type: "object";
@@ -3947,8 +4721,8 @@ export declare const $NewPostgresTrigger: {
         readonly is_flow: {
             readonly type: "boolean";
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly postgres_resource_path: {
             readonly type: "string";
@@ -3986,8 +4760,8 @@ export declare const $EditPostgresTrigger: {
         readonly is_flow: {
             readonly type: "boolean";
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly postgres_resource_path: {
             readonly type: "string";
@@ -4035,9 +4809,6 @@ export declare const $KafkaTrigger: {
         readonly error: {
             readonly type: "string";
         };
-        readonly enabled: {
-            readonly type: "boolean";
-        };
         readonly error_handler_path: {
             readonly type: "string";
         };
@@ -4048,7 +4819,7 @@ export declare const $KafkaTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["kafka_resource_path", "group_id", "topics", "enabled"];
+    readonly required: readonly ["kafka_resource_path", "group_id", "topics"];
 };
 export declare const $NewKafkaTrigger: {
     readonly type: "object";
@@ -4074,8 +4845,8 @@ export declare const $NewKafkaTrigger: {
                 readonly type: "string";
             };
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
@@ -4159,9 +4930,6 @@ export declare const $NatsTrigger: {
         readonly error: {
             readonly type: "string";
         };
-        readonly enabled: {
-            readonly type: "boolean";
-        };
         readonly error_handler_path: {
             readonly type: "string";
         };
@@ -4172,7 +4940,7 @@ export declare const $NatsTrigger: {
             readonly $ref: "#/components/schemas/Retry";
         };
     };
-    readonly required: readonly ["nats_resource_path", "use_jetstream", "subjects", "enabled"];
+    readonly required: readonly ["nats_resource_path", "use_jetstream", "subjects"];
 };
 export declare const $NewNatsTrigger: {
     readonly type: "object";
@@ -4204,8 +4972,8 @@ export declare const $NewNatsTrigger: {
                 readonly type: "string";
             };
         };
-        readonly enabled: {
-            readonly type: "boolean";
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
@@ -4312,6 +5080,9 @@ export declare const $NewEmailTrigger: {
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
         };
+        readonly mode: {
+            readonly $ref: "#/components/schemas/TriggerMode";
+        };
     };
     readonly required: readonly ["path", "script_path", "local_part", "is_flow"];
 };
@@ -4521,6 +5292,9 @@ export declare const $WorkerPing: {
         readonly wm_memory_usage: {
             readonly type: "number";
         };
+        readonly job_isolation: {
+            readonly type: "string";
+        };
     };
     readonly required: readonly ["worker", "worker_instance", "ping_at", "started_at", "ip", "jobs_executed", "worker_group", "wm_version"];
 };
@@ -4595,15 +5369,9 @@ export declare const $CreateWorkspaceFork: {
         readonly name: {
             readonly type: "string";
         };
-        readonly username: {
-            readonly type: "string";
-        };
         readonly color: {
             readonly type: "string";
         };
-        readonly parent_workspace_id: {
-            readonly type: "string";
-        };
     };
     readonly required: readonly ["id", "name", "parent_workspace_id"];
 };
@@ -4657,6 +5425,39 @@ export declare const $DependencyMap: {
         };
     };
 };
+export declare const $DependencyDependent: {
+    readonly type: "object";
+    readonly properties: {
+        readonly importer_path: {
+            readonly type: "string";
+        };
+        readonly importer_kind: {
+            readonly type: "string";
+            readonly enum: readonly ["script", "flow", "app"];
+        };
+        readonly importer_node_ids: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly nullable: true;
+        };
+    };
+    readonly required: readonly ["importer_path", "importer_kind"];
+};
+export declare const $DependentsAmount: {
+    readonly type: "object";
+    readonly properties: {
+        readonly imported_path: {
+            readonly type: "string";
+        };
+        readonly count: {
+            readonly type: "integer";
+            readonly format: "int64";
+        };
+    };
+    readonly required: readonly ["imported_path", "count"];
+};
 export declare const $WorkspaceInvite: {
     readonly type: "object";
     readonly properties: {
@@ -4710,8 +5511,11 @@ export declare const $GlobalUserInfo: {
         readonly operator_only: {
             readonly type: "boolean";
         };
+        readonly first_time_user: {
+            readonly type: "boolean";
+        };
     };
-    readonly required: readonly ["email", "login_type", "super_admin", "verified"];
+    readonly required: readonly ["email", "login_type", "super_admin", "verified", "first_time_user"];
 };
 export declare const $Flow: {
     readonly allOf: readonly [{
@@ -4724,6 +5528,9 @@ export declare const $Flow: {
             readonly lock_error_logs: {
                 readonly type: "string";
             };
+            readonly version_id: {
+                readonly type: "number";
+            };
         };
     }];
 };
@@ -4853,6 +5660,9 @@ export declare const $RestartedFrom: {
         readonly branch_or_iteration_n: {
             readonly type: "integer";
         };
+        readonly flow_version: {
+            readonly type: "integer";
+        };
     };
 };
 export declare const $Policy: {
@@ -5254,6 +6064,34 @@ export declare const $DucklakeSettings: {
         };
     };
 };
+export declare const $DataTableSettings: {
+    readonly type: "object";
+    readonly required: readonly ["datatables"];
+    readonly properties: {
+        readonly datatables: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly required: readonly ["database"];
+                readonly properties: {
+                    readonly database: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly resource_type: {
+                                readonly type: "string";
+                                readonly enum: readonly ["postgresql", "instance"];
+                            };
+                            readonly resource_path: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly required: readonly ["resource_type"];
+                    };
+                };
+            };
+        };
+    };
+};
 export declare const $DynamicInputData: {
     readonly type: "object";
     readonly properties: {
@@ -5837,6 +6675,112 @@ export declare const $OperatorSettings: {
         };
     };
 };
+export declare const $WorkspaceComparison: {
+    readonly type: "object";
+    readonly required: readonly ["all_ahead_items_visible", "all_behind_items_visible", "skipped_comparison", "diffs", "summary"];
+    readonly properties: {
+        readonly all_ahead_items_visible: {
+            readonly type: "boolean";
+            readonly description: "All items with changes ahead are visible by the user of the request.";
+        };
+        readonly all_behind_items_visible: {
+            readonly type: "boolean";
+            readonly description: "All items with changes behind are visible by the user of the request.";
+        };
+        readonly skipped_comparison: {
+            readonly type: "boolean";
+            readonly description: "Whether the comparison was skipped. This happens with old forks that where not being kept track of";
+        };
+        readonly diffs: {
+            readonly type: "array";
+            readonly description: "List of differences found between workspaces";
+            readonly items: {
+                readonly $ref: "#/components/schemas/WorkspaceItemDiff";
+            };
+        };
+        readonly summary: {
+            readonly $ref: "#/components/schemas/CompareSummary";
+            readonly description: "Summary statistics of the comparison";
+        };
+    };
+};
+export declare const $WorkspaceItemDiff: {
+    readonly type: "object";
+    readonly required: readonly ["kind", "path", "ahead", "behind", "has_changes", "exists_in_source", "exists_in_fork"];
+    readonly properties: {
+        readonly kind: {
+            readonly type: "string";
+            readonly enum: readonly ["script", "flow", "app", "resource", "variable"];
+            readonly description: "Type of the item";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Path of the item in the workspace";
+        };
+        readonly ahead: {
+            readonly type: "integer";
+            readonly description: "Number of versions source is ahead of target";
+        };
+        readonly behind: {
+            readonly type: "integer";
+            readonly description: "Number of versions source is behind target";
+        };
+        readonly has_changes: {
+            readonly type: "boolean";
+            readonly description: "Whether the item has any differences";
+        };
+        readonly exists_in_source: {
+            readonly type: "boolean";
+            readonly description: "If the item exists in the source workspace";
+        };
+        readonly exists_in_fork: {
+            readonly type: "boolean";
+            readonly description: "If the item exists in the fork workspace";
+        };
+    };
+};
+export declare const $CompareSummary: {
+    readonly type: "object";
+    readonly required: readonly ["total_diffs", "total_ahead", "total_behind", "scripts_changed", "flows_changed", "apps_changed", "resources_changed", "variables_changed", "conflicts"];
+    readonly properties: {
+        readonly total_diffs: {
+            readonly type: "integer";
+            readonly description: "Total number of items with differences";
+        };
+        readonly total_ahead: {
+            readonly type: "integer";
+            readonly description: "Total number of ahead changes";
+        };
+        readonly total_behind: {
+            readonly type: "integer";
+            readonly description: "Total number of behind changes";
+        };
+        readonly scripts_changed: {
+            readonly type: "integer";
+            readonly description: "Number of scripts with differences";
+        };
+        readonly flows_changed: {
+            readonly type: "integer";
+            readonly description: "Number of flows with differences";
+        };
+        readonly apps_changed: {
+            readonly type: "integer";
+            readonly description: "Number of apps with differences";
+        };
+        readonly resources_changed: {
+            readonly type: "integer";
+            readonly description: "Number of resources with differences";
+        };
+        readonly variables_changed: {
+            readonly type: "integer";
+            readonly description: "Number of variables with differences";
+        };
+        readonly conflicts: {
+            readonly type: "integer";
+            readonly description: "Number of items that are both ahead and behind (conflicts)";
+        };
+    };
+};
 export declare const $TeamInfo: {
     readonly type: "object";
     readonly required: readonly ["team_id", "team_name", "channels"];
@@ -5915,8 +6859,20 @@ export declare const $GithubInstallations: {
                     readonly required: readonly ["name", "url"];
                 };
             };
+            readonly total_count: {
+                readonly type: "number";
+                readonly description: "Total number of repositories available for this installation";
+            };
+            readonly per_page: {
+                readonly type: "number";
+                readonly description: "Number of repositories loaded per page";
+            };
+            readonly error: {
+                readonly type: "string";
+                readonly description: "Error message if token retrieval failed";
+            };
         };
-        readonly required: readonly ["installation_id", "account_id", "repositories"];
+        readonly required: readonly ["installation_id", "account_id", "repositories", "total_count", "per_page"];
     };
 };
 export declare const $WorkspaceGithubInstallation: {
@@ -5985,7 +6941,7 @@ export declare const $AssetUsageAccessType: {
 };
 export declare const $AssetKind: {
     readonly type: "string";
-    readonly enum: readonly ["s3object", "resource", "ducklake"];
+    readonly enum: readonly ["s3object", "resource", "ducklake", "datatable"];
 };
 export declare const $Asset: {
     readonly type: "object";