windmill-components 1.623.1 → 1.642.0

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

@@ -17,6 +17,10 @@ export declare const $OpenFlow: {
             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 on_behalf_of_email: {
+            readonly type: "string";
+            readonly description: "The flow will be run with the permissions of the user with this email.";
+        };
     };
     readonly required: readonly ["summary", "value"];
 };
@@ -324,12 +328,15 @@ export declare const $InputTransform: {
         readonly $ref: "#/components/schemas/StaticTransform";
     }, {
         readonly $ref: "#/components/schemas/JavascriptTransform";
+    }, {
+        readonly $ref: "#/components/schemas/AiTransform";
     }];
     readonly discriminator: {
         readonly propertyName: "type";
         readonly mapping: {
             readonly static: "#/components/schemas/StaticTransform";
             readonly javascript: "#/components/schemas/JavascriptTransform";
+            readonly ai: "#/components/schemas/AiTransform";
         };
     };
 };
@@ -362,6 +369,104 @@ export declare const $JavascriptTransform: {
     };
     readonly required: readonly ["expr", "type"];
 };
+export declare const $AiTransform: {
+    readonly type: "object";
+    readonly description: "Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.";
+    readonly properties: {
+        readonly type: {
+            readonly type: "string";
+            readonly enum: readonly ["ai"];
+        };
+    };
+    readonly required: readonly ["type"];
+};
+export declare const $ProviderConfig: {
+    readonly type: "object";
+    readonly description: "Complete AI provider configuration with resource reference and model selection";
+    readonly properties: {
+        readonly kind: {
+            readonly type: "string";
+            readonly description: "Supported AI provider types";
+            readonly enum: readonly ["openai", "azure_openai", "anthropic", "mistral", "deepseek", "googleai", "groq", "openrouter", "togetherai", "customai", "aws_bedrock"];
+        };
+        readonly resource: {
+            readonly type: "string";
+            readonly description: "Resource reference in format '$res:{resource_path}' pointing to provider credentials";
+        };
+        readonly model: {
+            readonly type: "string";
+            readonly description: "Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')";
+        };
+    };
+    readonly required: readonly ["kind", "resource", "model"];
+};
+export declare const $MemoryConfig: {
+    readonly description: "Conversation memory configuration";
+    readonly oneOf: readonly [{
+        readonly type: "object";
+        readonly description: "No conversation memory/context";
+        readonly properties: {
+            readonly kind: {
+                readonly type: "string";
+                readonly enum: readonly ["off"];
+            };
+        };
+        readonly required: readonly ["kind"];
+    }, {
+        readonly type: "object";
+        readonly description: "Automatic context management";
+        readonly properties: {
+            readonly kind: {
+                readonly type: "string";
+                readonly enum: readonly ["auto"];
+            };
+            readonly context_length: {
+                readonly type: "integer";
+                readonly description: "Maximum number of messages to retain in context";
+            };
+            readonly memory_id: {
+                readonly type: "string";
+                readonly description: "Identifier for persistent memory across agent invocations";
+            };
+        };
+        readonly required: readonly ["kind"];
+    }, {
+        readonly type: "object";
+        readonly description: "Explicit message history";
+        readonly properties: {
+            readonly kind: {
+                readonly type: "string";
+                readonly enum: readonly ["manual"];
+            };
+            readonly messages: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly description: "A single message in conversation history";
+                    readonly properties: {
+                        readonly role: {
+                            readonly type: "string";
+                            readonly enum: readonly ["user", "assistant", "system"];
+                        };
+                        readonly content: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly required: readonly ["role", "content"];
+                };
+            };
+        };
+        readonly required: readonly ["kind", "messages"];
+    }];
+    readonly discriminator: {
+        readonly propertyName: "kind";
+        readonly mapping: {
+            readonly off: "#/components/schemas/MemoryOff";
+            readonly auto: "#/components/schemas/MemoryAuto";
+            readonly manual: "#/components/schemas/MemoryManual";
+        };
+    };
+};
 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 [{
@@ -416,7 +521,7 @@ export declare const $RawScript: {
         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 enum: readonly ["deno", "bun", "python3", "go", "bash", "powershell", "postgresql", "mysql", "bigquery", "snowflake", "mssql", "oracledb", "graphql", "nativets", "php", "rust", "ansible", "csharp", "nu", "java", "ruby", "duckdb"];
         };
         readonly path: {
             readonly type: "string";
@@ -468,11 +573,13 @@ export declare const $RawScript: {
                     };
                     readonly access_type: {
                         readonly type: "string";
+                        readonly nullable: true;
                         readonly description: "Access level for this asset";
                         readonly enum: readonly ["r", "w", "rw"];
                     };
                     readonly alt_access_type: {
                         readonly type: "string";
+                        readonly nullable: true;
                         readonly description: "Alternative access level";
                         readonly enum: readonly ["r", "w", "rw"];
                     };
@@ -700,34 +807,110 @@ export declare const $AiAgent: {
             readonly description: "Input parameters for the AI agent mapped to their values";
             readonly properties: {
                 readonly provider: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly description: "Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined";
+                    readonly oneOf: readonly [{
+                        readonly type: "object";
+                        readonly description: "Static provider configuration passed directly to the AI agent";
+                        readonly properties: {
+                            readonly value: {
+                                readonly $ref: "#/components/schemas/ProviderConfig";
+                            };
+                            readonly type: {
+                                readonly type: "string";
+                                readonly enum: readonly ["static"];
+                            };
+                        };
+                        readonly required: readonly ["type", "value"];
+                    }, {
+                        readonly $ref: "#/components/schemas/JavascriptTransform";
+                    }, {
+                        readonly $ref: "#/components/schemas/AiTransform";
+                    }];
+                    readonly discriminator: {
+                        readonly propertyName: "type";
+                        readonly mapping: {
+                            readonly static: "#/components/schemas/StaticProviderTransform";
+                            readonly javascript: "#/components/schemas/JavascriptTransform";
+                            readonly ai: "#/components/schemas/AiTransform";
+                        };
+                    };
                 };
                 readonly output_type: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly allOf: readonly [{
+                        readonly $ref: "#/components/schemas/InputTransform";
+                    }];
+                    readonly description: "Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n";
                 };
                 readonly user_message: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly allOf: readonly [{
+                        readonly $ref: "#/components/schemas/InputTransform";
+                    }];
+                    readonly description: "The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax.";
                 };
                 readonly system_prompt: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly allOf: readonly [{
+                        readonly $ref: "#/components/schemas/InputTransform";
+                    }];
+                    readonly description: "System instructions that guide the AI's behavior, persona, and response style. Optional.";
                 };
                 readonly streaming: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly allOf: readonly [{
+                        readonly $ref: "#/components/schemas/InputTransform";
+                    }];
+                    readonly description: "Boolean. If true, stream the AI response incrementally.\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\n";
                 };
                 readonly memory: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly description: "Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined";
+                    readonly oneOf: readonly [{
+                        readonly type: "object";
+                        readonly description: "Static memory configuration passed directly to the AI agent";
+                        readonly properties: {
+                            readonly value: {
+                                readonly $ref: "#/components/schemas/MemoryConfig";
+                            };
+                            readonly type: {
+                                readonly type: "string";
+                                readonly enum: readonly ["static"];
+                            };
+                        };
+                        readonly required: readonly ["type", "value"];
+                    }, {
+                        readonly $ref: "#/components/schemas/JavascriptTransform";
+                    }, {
+                        readonly $ref: "#/components/schemas/AiTransform";
+                    }];
+                    readonly discriminator: {
+                        readonly propertyName: "type";
+                        readonly mapping: {
+                            readonly static: "#/components/schemas/StaticMemoryTransform";
+                            readonly javascript: "#/components/schemas/JavascriptTransform";
+                            readonly ai: "#/components/schemas/AiTransform";
+                        };
+                    };
                 };
                 readonly output_schema: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly allOf: readonly [{
+                        readonly $ref: "#/components/schemas/InputTransform";
+                    }];
+                    readonly description: "JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\n";
                 };
                 readonly user_images: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly allOf: readonly [{
+                        readonly $ref: "#/components/schemas/InputTransform";
+                    }];
+                    readonly description: "Array of image references for vision-capable models.\nFormat: Array<{ bucket: string, key: string }> - S3 object references\nExample: [{ bucket: 'my-bucket', key: 'images/photo.jpg' }]\n";
                 };
                 readonly max_completion_tokens: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly allOf: readonly [{
+                        readonly $ref: "#/components/schemas/InputTransform";
+                    }];
+                    readonly description: "Integer. Maximum number of tokens the AI will generate in its response.\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\n";
                 };
                 readonly temperature: {
-                    readonly $ref: "#/components/schemas/InputTransform";
+                    readonly allOf: readonly [{
+                        readonly $ref: "#/components/schemas/InputTransform";
+                    }];
+                    readonly description: "Float. Controls randomness/creativity of responses.\nRange: 0.0 to 2.0 (provider-dependent)\n- 0.0 = deterministic, focused responses\n- 0.7 = balanced (common default)\n- 1.0+ = more creative/random\n";
                 };
             };
             readonly required: readonly ["provider", "user_message", "output_type"];
@@ -1147,202 +1330,610 @@ export declare const $FlowNote: {
     };
     readonly required: readonly ["id", "text", "color", "type"];
 };
-export declare const $FlowConversation: {
+export declare const $HealthStatusResponse: {
     readonly type: "object";
-    readonly required: readonly ["id", "workspace_id", "flow_path", "created_at", "updated_at", "created_by"];
+    readonly description: "Health status response (cached with 5s TTL)";
+    readonly required: readonly ["status", "checked_at", "database_healthy", "workers_alive"];
     readonly properties: {
-        readonly id: {
-            readonly type: "string";
-            readonly format: "uuid";
-            readonly description: "Unique identifier for the conversation";
-        };
-        readonly workspace_id: {
-            readonly type: "string";
-            readonly description: "The workspace ID where the conversation belongs";
-        };
-        readonly flow_path: {
-            readonly type: "string";
-            readonly description: "Path of the flow this conversation is for";
-        };
-        readonly title: {
+        readonly status: {
             readonly type: "string";
-            readonly description: "Optional title for the conversation";
-            readonly nullable: true;
+            readonly enum: readonly ["healthy", "degraded", "unhealthy"];
+            readonly description: "Overall health status";
         };
-        readonly created_at: {
+        readonly checked_at: {
             readonly type: "string";
             readonly format: "date-time";
-            readonly description: "When the conversation was created";
+            readonly description: "Timestamp when the health check was actually performed (not cache return time)";
         };
-        readonly updated_at: {
-            readonly type: "string";
-            readonly format: "date-time";
-            readonly description: "When the conversation was last updated";
+        readonly database_healthy: {
+            readonly type: "boolean";
+            readonly description: "Whether the database is reachable";
         };
-        readonly created_by: {
-            readonly type: "string";
-            readonly description: "Username who created the conversation";
+        readonly workers_alive: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Number of workers that pinged within last 5 minutes";
         };
     };
 };
-export declare const $FlowConversationMessage: {
+export declare const $DetailedHealthResponse: {
     readonly type: "object";
-    readonly required: readonly ["id", "conversation_id", "message_type", "content", "created_at"];
+    readonly description: "Detailed health status response (always fresh, no caching)";
+    readonly required: readonly ["status", "checked_at", "version", "checks"];
     readonly properties: {
-        readonly id: {
-            readonly type: "string";
-            readonly format: "uuid";
-            readonly description: "Unique identifier for the message";
-        };
-        readonly conversation_id: {
-            readonly type: "string";
-            readonly format: "uuid";
-            readonly description: "The conversation this message belongs to";
-        };
-        readonly message_type: {
-            readonly type: "string";
-            readonly enum: readonly ["user", "assistant", "system", "tool"];
-            readonly description: "Type of the message";
-        };
-        readonly content: {
-            readonly type: "string";
-            readonly description: "The message content";
-        };
-        readonly job_id: {
+        readonly status: {
             readonly type: "string";
-            readonly format: "uuid";
-            readonly nullable: true;
-            readonly description: "Associated job ID if this message came from a flow run";
+            readonly enum: readonly ["healthy", "degraded", "unhealthy"];
+            readonly description: "Overall health status";
         };
-        readonly created_at: {
+        readonly checked_at: {
             readonly type: "string";
             readonly format: "date-time";
-            readonly description: "When the message was created";
+            readonly description: "Timestamp when the health check was performed";
         };
-        readonly step_name: {
+        readonly version: {
             readonly type: "string";
-            readonly description: "The step name that produced that message";
+            readonly description: "Server version (e.g., \"EE 1.615.3\")";
         };
-        readonly success: {
-            readonly type: "boolean";
-            readonly description: "Whether the message is a success";
+        readonly checks: {
+            readonly $ref: "#/components/schemas/HealthChecks";
         };
     };
 };
-export declare const $EndpointTool: {
+export declare const $HealthChecks: {
     readonly type: "object";
-    readonly required: readonly ["name", "description", "instructions", "path", "method"];
+    readonly description: "Detailed health checks";
+    readonly required: readonly ["database", "readiness"];
     readonly properties: {
-        readonly name: {
-            readonly type: "string";
-            readonly description: "The tool name/operation ID";
-        };
-        readonly description: {
-            readonly type: "string";
-            readonly description: "Short description of the tool";
-        };
-        readonly instructions: {
-            readonly type: "string";
-            readonly description: "Detailed instructions for using the tool";
-        };
-        readonly path: {
-            readonly type: "string";
-            readonly description: "API endpoint path";
-        };
-        readonly method: {
-            readonly type: "string";
-            readonly description: "HTTP method (GET, POST, etc.)";
+        readonly database: {
+            readonly $ref: "#/components/schemas/DatabaseHealth";
         };
-        readonly path_params_schema: {
-            readonly type: "object";
-            readonly description: "JSON schema for path parameters";
+        readonly workers: {
+            readonly $ref: "#/components/schemas/WorkersHealth";
+            readonly description: "Worker status (null if database is unreachable)";
             readonly nullable: true;
         };
-        readonly query_params_schema: {
-            readonly type: "object";
-            readonly description: "JSON schema for query parameters";
+        readonly queue: {
+            readonly $ref: "#/components/schemas/QueueHealth";
+            readonly description: "Queue status (null if database is unreachable)";
             readonly nullable: true;
         };
-        readonly body_schema: {
-            readonly type: "object";
-            readonly description: "JSON schema for request body";
-            readonly nullable: true;
+        readonly readiness: {
+            readonly $ref: "#/components/schemas/ReadinessHealth";
         };
     };
 };
-export declare const $AIProvider: {
-    readonly type: "string";
-    readonly enum: readonly ["openai", "azure_openai", "anthropic", "mistral", "deepseek", "googleai", "groq", "openrouter", "togetherai", "aws_bedrock", "customai"];
-};
-export declare const $GitSyncObjectType: {
-    readonly type: "string";
-    readonly enum: readonly ["script", "flow", "app", "folder", "resource", "variable", "secret", "resourcetype", "schedule", "user", "group", "trigger", "settings", "key"];
-};
-export declare const $AIProviderModel: {
+export declare const $DatabaseHealth: {
     readonly type: "object";
+    readonly description: "Database health status";
+    readonly required: readonly ["healthy", "latency_ms", "pool"];
     readonly properties: {
-        readonly model: {
-            readonly type: "string";
+        readonly healthy: {
+            readonly type: "boolean";
+            readonly description: "Whether the database is reachable";
         };
-        readonly provider: {
-            readonly $ref: "#/components/schemas/AIProvider";
+        readonly latency_ms: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Database query latency in milliseconds";
+        };
+        readonly pool: {
+            readonly $ref: "#/components/schemas/PoolStats";
         };
     };
-    readonly required: readonly ["model", "provider"];
 };
-export declare const $AIProviderConfig: {
+export declare const $PoolStats: {
     readonly type: "object";
+    readonly description: "Database connection pool statistics";
+    readonly required: readonly ["size", "idle", "max_connections"];
     readonly properties: {
-        readonly resource_path: {
-            readonly type: "string";
+        readonly size: {
+            readonly type: "integer";
+            readonly description: "Current number of connections in the pool";
         };
-        readonly models: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
+        readonly idle: {
+            readonly type: "integer";
+            readonly description: "Number of idle connections";
+        };
+        readonly max_connections: {
+            readonly type: "integer";
+            readonly description: "Maximum number of connections allowed";
         };
     };
-    readonly required: readonly ["resource_path", "models"];
 };
-export declare const $AIConfig: {
+export declare const $WorkersHealth: {
     readonly type: "object";
+    readonly description: "Workers health status";
+    readonly required: readonly ["healthy", "active_count", "worker_groups", "min_version", "versions"];
     readonly properties: {
-        readonly providers: {
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly $ref: "#/components/schemas/AIProviderConfig";
-            };
-        };
-        readonly default_model: {
-            readonly $ref: "#/components/schemas/AIProviderModel";
+        readonly healthy: {
+            readonly type: "boolean";
+            readonly description: "Whether any workers are active";
         };
-        readonly code_completion_model: {
-            readonly $ref: "#/components/schemas/AIProviderModel";
+        readonly active_count: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Number of active workers (pinged in last 5 minutes)";
         };
-        readonly custom_prompts: {
-            readonly type: "object";
-            readonly additionalProperties: {
+        readonly worker_groups: {
+            readonly type: "array";
+            readonly items: {
                 readonly type: "string";
             };
+            readonly description: "List of active worker groups";
         };
-        readonly max_tokens_per_model: {
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly type: "integer";
-                readonly minimum: 1;
-                readonly maximum: 2000000;
-            };
-        };
-    };
-};
-export declare const $Alert: {
-    readonly type: "object";
-    readonly properties: {
-        readonly name: {
+        readonly min_version: {
             readonly type: "string";
+            readonly description: "Minimum required worker version";
         };
-        readonly tags_to_monitor: {
+        readonly versions: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "List of active worker versions";
+        };
+    };
+};
+export declare const $QueueHealth: {
+    readonly type: "object";
+    readonly description: "Job queue status";
+    readonly required: readonly ["pending_jobs", "running_jobs"];
+    readonly properties: {
+        readonly pending_jobs: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Number of pending jobs in the queue";
+        };
+        readonly running_jobs: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Number of currently running jobs";
+        };
+    };
+};
+export declare const $ReadinessHealth: {
+    readonly type: "object";
+    readonly description: "Server readiness status";
+    readonly required: readonly ["healthy"];
+    readonly properties: {
+        readonly healthy: {
+            readonly type: "boolean";
+            readonly description: "Whether the server is ready to accept requests";
+        };
+    };
+};
+export declare const $AutoInviteConfig: {
+    readonly type: "object";
+    readonly description: "Configuration for auto-inviting users to the workspace";
+    readonly properties: {
+        readonly enabled: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+        readonly domain: {
+            readonly type: "string";
+        };
+        readonly operator: {
+            readonly type: "boolean";
+            readonly default: false;
+            readonly description: "If true, auto-invited users are added as operators. If false, they are added as developers.";
+        };
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["invite", "add"];
+            readonly default: "invite";
+        };
+        readonly instance_groups: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly instance_groups_roles: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+export declare const $ErrorHandlerConfig: {
+    readonly type: "object";
+    readonly description: "Configuration for the workspace error handler";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Path to the error handler script or flow";
+        };
+        readonly extra_args: {
+            readonly $ref: "#/components/schemas/ScriptArgs";
+        };
+        readonly muted_on_cancel: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+        readonly muted_on_user_path: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+    };
+};
+export declare const $SuccessHandlerConfig: {
+    readonly type: "object";
+    readonly description: "Configuration for the workspace success handler";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Path to the success handler script or flow";
+        };
+        readonly extra_args: {
+            readonly $ref: "#/components/schemas/ScriptArgs";
+        };
+    };
+};
+export declare const $EditErrorHandler: {
+    readonly description: "Request body for editing the workspace error handler. Accepts both new grouped format and legacy flat format for backward compatibility.";
+    readonly oneOf: readonly [{
+        readonly $ref: "#/components/schemas/EditErrorHandlerNew";
+    }, {
+        readonly $ref: "#/components/schemas/EditErrorHandlerLegacy";
+    }];
+};
+export declare const $EditErrorHandlerNew: {
+    readonly type: "object";
+    readonly description: "New grouped format for editing error handler";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Path to the error handler script or flow";
+        };
+        readonly extra_args: {
+            readonly $ref: "#/components/schemas/ScriptArgs";
+        };
+        readonly muted_on_cancel: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+        readonly muted_on_user_path: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+    };
+};
+export declare const $EditErrorHandlerLegacy: {
+    readonly type: "object";
+    readonly description: "Legacy flat format for editing error handler (deprecated, use new format)";
+    readonly properties: {
+        readonly error_handler: {
+            readonly type: "string";
+            readonly description: "Path to the error handler script or flow";
+        };
+        readonly error_handler_extra_args: {
+            readonly $ref: "#/components/schemas/ScriptArgs";
+        };
+        readonly error_handler_muted_on_cancel: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+    };
+};
+export declare const $EditSuccessHandler: {
+    readonly description: "Request body for editing the workspace success handler. Accepts both new grouped format and legacy flat format for backward compatibility.";
+    readonly oneOf: readonly [{
+        readonly $ref: "#/components/schemas/EditSuccessHandlerNew";
+    }, {
+        readonly $ref: "#/components/schemas/EditSuccessHandlerLegacy";
+    }];
+};
+export declare const $EditSuccessHandlerNew: {
+    readonly type: "object";
+    readonly description: "New grouped format for editing success handler";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Path to the success handler script or flow";
+        };
+        readonly extra_args: {
+            readonly $ref: "#/components/schemas/ScriptArgs";
+        };
+    };
+};
+export declare const $EditSuccessHandlerLegacy: {
+    readonly type: "object";
+    readonly description: "Legacy flat format for editing success handler (deprecated, use new format)";
+    readonly properties: {
+        readonly success_handler: {
+            readonly type: "string";
+            readonly description: "Path to the success handler script or flow";
+        };
+        readonly success_handler_extra_args: {
+            readonly $ref: "#/components/schemas/ScriptArgs";
+        };
+    };
+};
+export declare const $VaultSettings: {
+    readonly type: "object";
+    readonly required: readonly ["address", "mount_path"];
+    readonly properties: {
+        readonly address: {
+            readonly type: "string";
+            readonly description: "HashiCorp Vault server address (e.g., https://vault.company.com:8200)";
+        };
+        readonly mount_path: {
+            readonly type: "string";
+            readonly description: "KV v2 secrets engine mount path (e.g., windmill)";
+        };
+        readonly jwt_role: {
+            readonly type: "string";
+            readonly description: "Vault JWT auth role name for Windmill (optional, if not provided token auth is used)";
+        };
+        readonly namespace: {
+            readonly type: "string";
+            readonly description: "Vault Enterprise namespace (optional)";
+        };
+        readonly token: {
+            readonly type: "string";
+            readonly description: "Static Vault token for testing/development (optional, if provided this is used instead of JWT authentication)";
+        };
+    };
+};
+export declare const $SecretMigrationFailure: {
+    readonly type: "object";
+    readonly required: readonly ["workspace_id", "path", "error"];
+    readonly properties: {
+        readonly workspace_id: {
+            readonly type: "string";
+            readonly description: "Workspace ID where the secret is located";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Path of the secret that failed to migrate";
+        };
+        readonly error: {
+            readonly type: "string";
+            readonly description: "Error message";
+        };
+    };
+};
+export declare const $SecretMigrationReport: {
+    readonly type: "object";
+    readonly required: readonly ["total_secrets", "migrated_count", "failed_count", "failures"];
+    readonly properties: {
+        readonly total_secrets: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Total number of secrets found";
+        };
+        readonly migrated_count: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Number of secrets successfully migrated";
+        };
+        readonly failed_count: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly description: "Number of secrets that failed to migrate";
+        };
+        readonly failures: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/SecretMigrationFailure";
+            };
+            readonly description: "Details of any failures encountered during migration";
+        };
+    };
+};
+export declare const $JwksResponse: {
+    readonly type: "object";
+    readonly required: readonly ["keys"];
+    readonly properties: {
+        readonly keys: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+            };
+            readonly description: "Array of JSON Web Keys for JWT verification";
+        };
+    };
+};
+export declare const $FlowConversation: {
+    readonly type: "object";
+    readonly required: readonly ["id", "workspace_id", "flow_path", "created_at", "updated_at", "created_by"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique identifier for the conversation";
+        };
+        readonly workspace_id: {
+            readonly type: "string";
+            readonly description: "The workspace ID where the conversation belongs";
+        };
+        readonly flow_path: {
+            readonly type: "string";
+            readonly description: "Path of the flow this conversation is for";
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly description: "Optional title for the conversation";
+            readonly nullable: true;
+        };
+        readonly created_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "When the conversation was created";
+        };
+        readonly updated_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "When the conversation was last updated";
+        };
+        readonly created_by: {
+            readonly type: "string";
+            readonly description: "Username who created the conversation";
+        };
+    };
+};
+export declare const $FlowConversationMessage: {
+    readonly type: "object";
+    readonly required: readonly ["id", "conversation_id", "message_type", "content", "created_at"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique identifier for the message";
+        };
+        readonly conversation_id: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "The conversation this message belongs to";
+        };
+        readonly message_type: {
+            readonly type: "string";
+            readonly enum: readonly ["user", "assistant", "system", "tool"];
+            readonly description: "Type of the message";
+        };
+        readonly content: {
+            readonly type: "string";
+            readonly description: "The message content";
+        };
+        readonly job_id: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly nullable: true;
+            readonly description: "Associated job ID if this message came from a flow run";
+        };
+        readonly created_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "When the message was created";
+        };
+        readonly step_name: {
+            readonly type: "string";
+            readonly description: "The step name that produced that message";
+        };
+        readonly success: {
+            readonly type: "boolean";
+            readonly description: "Whether the message is a success";
+        };
+    };
+};
+export declare const $EndpointTool: {
+    readonly type: "object";
+    readonly required: readonly ["name", "description", "instructions", "path", "method"];
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "The tool name/operation ID";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Short description of the tool";
+        };
+        readonly instructions: {
+            readonly type: "string";
+            readonly description: "Detailed instructions for using the tool";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "API endpoint path";
+        };
+        readonly method: {
+            readonly type: "string";
+            readonly description: "HTTP method (GET, POST, etc.)";
+        };
+        readonly path_params_schema: {
+            readonly type: "object";
+            readonly description: "JSON schema for path parameters";
+            readonly nullable: true;
+        };
+        readonly query_params_schema: {
+            readonly type: "object";
+            readonly description: "JSON schema for query parameters";
+            readonly nullable: true;
+        };
+        readonly body_schema: {
+            readonly type: "object";
+            readonly description: "JSON schema for request body";
+            readonly nullable: true;
+        };
+    };
+};
+export declare const $AIProvider: {
+    readonly type: "string";
+    readonly enum: readonly ["openai", "azure_openai", "anthropic", "mistral", "deepseek", "googleai", "groq", "openrouter", "togetherai", "aws_bedrock", "customai"];
+};
+export declare const $GitSyncObjectType: {
+    readonly type: "string";
+    readonly enum: readonly ["script", "flow", "app", "folder", "resource", "variable", "secret", "resourcetype", "schedule", "user", "group", "trigger", "settings", "key"];
+};
+export declare const $AIProviderModel: {
+    readonly type: "object";
+    readonly properties: {
+        readonly model: {
+            readonly type: "string";
+        };
+        readonly provider: {
+            readonly $ref: "#/components/schemas/AIProvider";
+        };
+    };
+    readonly required: readonly ["model", "provider"];
+};
+export declare const $AIProviderConfig: {
+    readonly type: "object";
+    readonly properties: {
+        readonly resource_path: {
+            readonly type: "string";
+        };
+        readonly models: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly required: readonly ["resource_path", "models"];
+};
+export declare const $AIConfig: {
+    readonly type: "object";
+    readonly properties: {
+        readonly providers: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly $ref: "#/components/schemas/AIProviderConfig";
+            };
+        };
+        readonly default_model: {
+            readonly $ref: "#/components/schemas/AIProviderModel";
+        };
+        readonly code_completion_model: {
+            readonly $ref: "#/components/schemas/AIProviderModel";
+        };
+        readonly custom_prompts: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
+        readonly max_tokens_per_model: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 2000000;
+            };
+        };
+    };
+};
+export declare const $Alert: {
+    readonly type: "object";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly tags_to_monitor: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
@@ -1746,7 +2337,7 @@ export declare const $ScriptHistory: {
 export declare const $ScriptArgs: {
     readonly type: "object";
     readonly description: "The arguments to pass to the script or flow";
-    readonly additionalProperties: {};
+    readonly additionalProperties: true;
 };
 export declare const $Input: {
     readonly type: "object";
@@ -2501,6 +3092,15 @@ export declare const $Login: {
     };
     readonly required: readonly ["email", "password"];
 };
+export declare const $PasswordResetResponse: {
+    readonly type: "object";
+    readonly properties: {
+        readonly message: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["message"];
+};
 export declare const $EditWorkspaceUser: {
     readonly type: "object";
     readonly properties: {
@@ -2874,7 +3474,7 @@ export declare const $MainArgSignature: {
 };
 export declare const $ScriptLang: {
     readonly type: "string";
-    readonly enum: readonly ["python3", "deno", "go", "bash", "powershell", "postgresql", "mysql", "bigquery", "snowflake", "mssql", "oracledb", "graphql", "nativets", "bun", "php", "rust", "ansible", "csharp", "nu", "java", "ruby", "duckdb"];
+    readonly enum: readonly ["python3", "deno", "go", "bash", "powershell", "postgresql", "mysql", "bigquery", "snowflake", "mssql", "oracledb", "graphql", "nativets", "bun", "php", "rust", "ansible", "csharp", "nu", "java", "ruby", "duckdb", "bunnative"];
 };
 export declare const $Preview: {
     readonly type: "object";
@@ -3125,99 +3725,141 @@ export declare const $Schedule: {
     readonly properties: {
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this schedule";
         };
         readonly edited_by: {
             readonly type: "string";
+            readonly description: "Username of the last person who edited this schedule";
         };
         readonly edited_at: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly description: "Timestamp of the last edit";
         };
         readonly schedule: {
             readonly type: "string";
+            readonly description: "Cron expression with 6 fields (seconds, minutes, hours, day of month, month, day of week). Example '0 0 12 * * *' for daily at noon";
         };
         readonly timezone: {
             readonly type: "string";
+            readonly description: "IANA timezone for the schedule (e.g., 'UTC', 'Europe/Paris', 'America/New_York')";
         };
         readonly enabled: {
             readonly type: "boolean";
+            readonly description: "Whether the schedule is currently active and will trigger jobs";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when triggered";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly nullable: true;
         };
         readonly extra_perms: {
             readonly type: "object";
             readonly additionalProperties: {
                 readonly type: "boolean";
             };
+            readonly description: "Additional permissions for this schedule";
         };
         readonly email: {
             readonly type: "string";
+            readonly description: "Email of the user who owns this schedule, used for permissioned_as";
         };
         readonly error: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Last error message if the schedule failed to trigger";
         };
         readonly on_failure: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Path to a script or flow to run when the scheduled job fails";
         };
         readonly on_failure_times: {
             readonly type: "number";
+            readonly nullable: true;
+            readonly description: "Number of consecutive failures before the on_failure handler is triggered (default 1)";
         };
         readonly on_failure_exact: {
             readonly type: "boolean";
+            readonly nullable: true;
+            readonly description: "If true, trigger on_failure handler only on exactly N failures, not on every failure after N";
         };
         readonly on_failure_extra_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly nullable: true;
         };
         readonly on_recovery: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Path to a script or flow to run when the schedule recovers after failures";
         };
         readonly on_recovery_times: {
             readonly type: "number";
+            readonly nullable: true;
+            readonly description: "Number of consecutive successes before the on_recovery handler is triggered (default 1)";
         };
         readonly on_recovery_extra_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly nullable: true;
         };
         readonly on_success: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Path to a script or flow to run after each successful execution";
         };
         readonly on_success_extra_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly nullable: true;
         };
         readonly ws_error_handler_muted: {
             readonly type: "boolean";
+            readonly description: "If true, the workspace-level error handler will not be triggered for this schedule's failures";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly nullable: true;
         };
         readonly summary: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Short summary describing the purpose of this schedule";
         };
         readonly description: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Detailed description of what this schedule does";
         };
         readonly no_flow_overlap: {
             readonly type: "boolean";
+            readonly description: "If true, skip this schedule's execution if the previous run is still in progress (prevents concurrent runs)";
         };
         readonly tag: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Worker tag to route jobs to specific worker groups";
         };
         readonly paused_until: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly nullable: true;
+            readonly description: "ISO 8601 datetime until which the schedule is paused. Schedule resumes automatically after this time";
         };
         readonly cron_version: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Cron parser version. Use 'v2' for extended syntax with additional features";
         };
         readonly dynamic_skip: {
             readonly type: "string";
-            readonly description: "Path to a script that validates scheduled datetimes. Receives scheduled_for datetime and returns boolean.";
+            readonly nullable: true;
+            readonly description: "Path to a script that validates scheduled datetimes. Receives scheduled_for datetime and returns boolean to skip (true) or run (false)";
         };
     };
     readonly required: readonly ["path", "edited_by", "edited_at", "schedule", "script_path", "timezone", "extra_perms", "is_flow", "enabled", "email"];
@@ -3258,104 +3900,116 @@ export declare const $NewSchedule: {
     readonly properties: {
         readonly path: {
             readonly type: "string";
-            readonly description: "The path where the schedule will be created";
+            readonly description: "The unique path identifier for this schedule";
         };
         readonly schedule: {
             readonly type: "string";
-            readonly description: "The cron schedule to trigger the script or flow. Should include seconds.";
+            readonly description: "Cron expression with 6 fields (seconds, minutes, hours, day of month, month, day of week). Example '0 0 12 * * *' for daily at noon";
         };
         readonly timezone: {
             readonly type: "string";
-            readonly description: "The timezone to use for the cron schedule";
+            readonly description: "IANA timezone for the schedule (e.g., 'UTC', 'Europe/Paris', 'America/New_York')";
         };
         readonly script_path: {
             readonly type: "string";
-            readonly description: "The path to the script or flow to trigger";
+            readonly description: "Path to the script or flow to execute when triggered";
         };
         readonly is_flow: {
             readonly type: "boolean";
-            readonly description: "Whether the schedule is for a flow";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly args: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
-            readonly description: "The arguments to pass to the script or flow";
         };
         readonly enabled: {
             readonly type: "boolean";
-            readonly description: "Whether the schedule is enabled";
+            readonly description: "Whether the schedule is currently active and will trigger jobs";
         };
         readonly on_failure: {
             readonly type: "string";
-            readonly description: "The path to the script or flow to trigger on failure";
+            readonly nullable: true;
+            readonly description: "Path to a script or flow to run when the scheduled job fails";
         };
         readonly on_failure_times: {
             readonly type: "number";
-            readonly description: "The number of times to retry on failure";
+            readonly nullable: true;
+            readonly description: "Number of consecutive failures before the on_failure handler is triggered (default 1)";
         };
         readonly on_failure_exact: {
             readonly type: "boolean";
-            readonly description: "Whether the schedule should only run on the exact time";
+            readonly nullable: true;
+            readonly description: "If true, trigger on_failure handler only on exactly N failures, not on every failure after N";
         };
         readonly on_failure_extra_args: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
-            readonly description: "The arguments to pass to the script or flow on failure";
         };
         readonly on_recovery: {
             readonly type: "string";
-            readonly description: "The path to the script or flow to trigger on recovery";
+            readonly nullable: true;
+            readonly description: "Path to a script or flow to run when the schedule recovers after failures";
         };
         readonly on_recovery_times: {
             readonly type: "number";
-            readonly description: "The number of times to retry on recovery";
+            readonly nullable: true;
+            readonly description: "Number of consecutive successes before the on_recovery handler is triggered (default 1)";
         };
         readonly on_recovery_extra_args: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
-            readonly description: "The arguments to pass to the script or flow on recovery";
         };
         readonly on_success: {
             readonly type: "string";
-            readonly description: "The path to the script or flow to trigger on success";
+            readonly nullable: true;
+            readonly description: "Path to a script or flow to run after each successful execution";
         };
         readonly on_success_extra_args: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
-            readonly description: "The arguments to pass to the script or flow on success";
         };
         readonly ws_error_handler_muted: {
             readonly type: "boolean";
-            readonly description: "Whether the WebSocket error handler is muted";
+            readonly description: "If true, the workspace-level error handler will not be triggered for this schedule's failures";
         };
         readonly retry: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/Retry";
-            readonly description: "The retry configuration for the schedule";
         };
         readonly no_flow_overlap: {
             readonly type: "boolean";
-            readonly description: "Whether the schedule should not run if a flow is already running";
+            readonly description: "If true, skip this schedule's execution if the previous run is still in progress (prevents concurrent runs)";
         };
         readonly summary: {
             readonly type: "string";
-            readonly description: "The summary of the schedule";
+            readonly nullable: true;
+            readonly description: "Short summary describing the purpose of this schedule";
         };
         readonly description: {
             readonly type: "string";
-            readonly description: "The description of the schedule";
+            readonly nullable: true;
+            readonly description: "Detailed description of what this schedule does";
         };
         readonly tag: {
             readonly type: "string";
-            readonly description: "The tag of the schedule";
+            readonly nullable: true;
+            readonly description: "Worker tag to route jobs to specific worker groups";
         };
         readonly paused_until: {
             readonly type: "string";
-            readonly description: "The date and time the schedule will be paused until";
+            readonly nullable: true;
             readonly format: "date-time";
+            readonly description: "ISO 8601 datetime until which the schedule is paused. Schedule resumes automatically after this time";
         };
         readonly cron_version: {
             readonly type: "string";
-            readonly description: "The version of the cron schedule to use (last is v2)";
+            readonly nullable: true;
+            readonly description: "Cron parser version. Use 'v2' for extended syntax with additional features";
         };
         readonly dynamic_skip: {
             readonly type: "string";
-            readonly description: "Path to a script that validates scheduled datetimes. Receives scheduled_for datetime and returns boolean.";
+            readonly nullable: true;
+            readonly description: "Path to a script that validates scheduled datetimes. Receives scheduled_for datetime and returns boolean to skip (true) or run (false)";
         };
     };
     readonly required: readonly ["path", "schedule", "timezone", "script_path", "is_flow", "args"];
@@ -3365,88 +4019,100 @@ export declare const $EditSchedule: {
     readonly properties: {
         readonly schedule: {
             readonly type: "string";
-            readonly description: "The cron schedule to trigger the script or flow. Should include seconds.";
+            readonly description: "Cron expression with 6 fields (seconds, minutes, hours, day of month, month, day of week). Example '0 0 12 * * *' for daily at noon";
         };
         readonly timezone: {
             readonly type: "string";
-            readonly description: "The timezone to use for the cron schedule";
+            readonly description: "IANA timezone for the schedule (e.g., 'UTC', 'Europe/Paris', 'America/New_York')";
         };
         readonly args: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
-            readonly description: "The arguments to pass to the script or flow";
         };
         readonly on_failure: {
             readonly type: "string";
-            readonly description: "The path to the script or flow to trigger on failure";
+            readonly nullable: true;
+            readonly description: "Path to a script or flow to run when the scheduled job fails";
         };
         readonly on_failure_times: {
             readonly type: "number";
-            readonly description: "The number of times to retry on failure";
+            readonly nullable: true;
+            readonly description: "Number of consecutive failures before the on_failure handler is triggered (default 1)";
         };
         readonly on_failure_exact: {
             readonly type: "boolean";
-            readonly description: "Whether the schedule should only run on the exact time";
+            readonly nullable: true;
+            readonly description: "If true, trigger on_failure handler only on exactly N failures, not on every failure after N";
         };
         readonly on_failure_extra_args: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
-            readonly description: "The arguments to pass to the script or flow on failure";
         };
         readonly on_recovery: {
             readonly type: "string";
-            readonly description: "The path to the script or flow to trigger on recovery";
+            readonly nullable: true;
+            readonly description: "Path to a script or flow to run when the schedule recovers after failures";
         };
         readonly on_recovery_times: {
             readonly type: "number";
-            readonly description: "The number of times to retry on recovery";
+            readonly nullable: true;
+            readonly description: "Number of consecutive successes before the on_recovery handler is triggered (default 1)";
         };
         readonly on_recovery_extra_args: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
-            readonly description: "The arguments to pass to the script or flow on recovery";
         };
         readonly on_success: {
             readonly type: "string";
-            readonly description: "The path to the script or flow to trigger on success";
+            readonly nullable: true;
+            readonly description: "Path to a script or flow to run after each successful execution";
         };
         readonly on_success_extra_args: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
-            readonly description: "The arguments to pass to the script or flow on success";
         };
         readonly ws_error_handler_muted: {
             readonly type: "boolean";
-            readonly description: "Whether the WebSocket error handler is muted";
+            readonly description: "If true, the workspace-level error handler will not be triggered for this schedule's failures";
         };
         readonly retry: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/Retry";
-            readonly description: "The retry configuration for the schedule";
         };
         readonly no_flow_overlap: {
             readonly type: "boolean";
-            readonly description: "Whether the schedule should not run if a flow is already running";
+            readonly description: "If true, skip this schedule's execution if the previous run is still in progress (prevents concurrent runs)";
         };
         readonly summary: {
             readonly type: "string";
-            readonly description: "The summary of the schedule";
+            readonly nullable: true;
+            readonly description: "Short summary describing the purpose of this schedule";
         };
         readonly description: {
             readonly type: "string";
-            readonly description: "The description of the schedule";
+            readonly nullable: true;
+            readonly description: "Detailed description of what this schedule does";
         };
         readonly tag: {
             readonly type: "string";
-            readonly description: "The tag of the schedule";
+            readonly nullable: true;
+            readonly description: "Worker tag to route jobs to specific worker groups";
         };
         readonly paused_until: {
             readonly type: "string";
-            readonly description: "The date and time the schedule will be paused until";
+            readonly nullable: true;
             readonly format: "date-time";
+            readonly description: "ISO 8601 datetime until which the schedule is paused. Schedule resumes automatically after this time";
         };
         readonly cron_version: {
             readonly type: "string";
-            readonly description: "The version of the cron schedule to use (last is v2)";
+            readonly nullable: true;
+            readonly description: "Cron parser version. Use 'v2' for extended syntax with additional features";
         };
         readonly dynamic_skip: {
             readonly type: "string";
-            readonly description: "Path to a script that validates scheduled datetimes. Receives scheduled_for datetime and returns boolean.";
+            readonly nullable: true;
+            readonly description: "Path to a script that validates scheduled datetimes. Receives scheduled_for datetime and returns boolean to skip (true) or run (false)";
         };
     };
     readonly required: readonly ["schedule", "timezone", "args"];
@@ -3454,7 +4120,7 @@ export declare const $EditSchedule: {
 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"];
+    readonly enum: readonly ["webhook", "default_email", "email", "schedule", "http", "websocket", "postgres", "kafka", "nats", "mqtt", "sqs", "gcp", "google"];
 };
 export declare const $TriggerMode: {
     readonly description: "job trigger mode";
@@ -3466,34 +4132,43 @@ export declare const $TriggerExtraProperty: {
     readonly properties: {
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when triggered";
         };
         readonly email: {
             readonly type: "string";
+            readonly description: "Email of the user who owns this trigger, used for permissioned_as";
         };
         readonly extra_perms: {
             readonly type: "object";
+            readonly description: "Additional permissions for this trigger";
             readonly additionalProperties: {
                 readonly type: "boolean";
             };
         };
         readonly workspace_id: {
             readonly type: "string";
+            readonly description: "The workspace this trigger belongs to";
         };
         readonly edited_by: {
             readonly type: "string";
+            readonly description: "Username of the last person who edited this trigger";
         };
         readonly edited_at: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly description: "Timestamp of the last edit";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
+            readonly description: "Trigger mode (enabled/disabled)";
         };
     };
     readonly required: readonly ["path", "script_path", "email", "extra_perms", "workspace_id", "edited_by", "edited_at", "is_flow", "mode"];
@@ -3633,60 +4308,82 @@ export declare const $HttpTrigger: {
     readonly properties: {
         readonly route_path: {
             readonly type: "string";
+            readonly description: "The URL route path that will trigger this endpoint (e.g., 'api/myendpoint'). Must NOT start with a /.";
         };
         readonly static_asset_config: {
             readonly type: "object";
+            readonly nullable: true;
+            readonly description: "Configuration for serving static assets (s3 bucket, storage path, filename)";
             readonly properties: {
                 readonly s3: {
                     readonly type: "string";
+                    readonly description: "S3 bucket path for static assets";
                 };
                 readonly storage: {
                     readonly type: "string";
+                    readonly description: "Storage path for static assets";
                 };
                 readonly filename: {
                     readonly type: "string";
+                    readonly description: "Filename for the static asset";
                 };
             };
             readonly required: readonly ["s3"];
         };
         readonly http_method: {
             readonly $ref: "#/components/schemas/HttpMethod";
+            readonly description: "HTTP method (get, post, put, delete, patch) that triggers this endpoint";
         };
         readonly authentication_resource_path: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Path to the resource containing authentication configuration (for api_key, basic_http, custom_script, signature methods)";
         };
         readonly summary: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Short summary describing the purpose of this trigger";
         };
         readonly description: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Detailed description of what this trigger does";
         };
         readonly request_type: {
             readonly $ref: "#/components/schemas/HttpRequestType";
+            readonly description: "How the request is handled - 'sync' waits for result, 'async' returns job ID immediately, 'sync_sse' streams results via Server-Sent Events";
         };
         readonly authentication_method: {
             readonly $ref: "#/components/schemas/AuthenticationMethod";
+            readonly description: "How requests are authenticated - 'none' (public), 'windmill' (Windmill token), 'api_key', 'basic_http', 'custom_script', 'signature'";
         };
         readonly is_static_website: {
             readonly type: "boolean";
+            readonly description: "If true, serves static files from S3/storage instead of running a script";
         };
         readonly workspaced_route: {
             readonly type: "boolean";
+            readonly description: "If true, the route includes the workspace ID in the path";
         };
         readonly wrap_body: {
             readonly type: "boolean";
+            readonly description: "If true, wraps the request body in a 'body' parameter";
         };
         readonly raw_string: {
             readonly type: "boolean";
+            readonly description: "If true, passes the request body as a raw string instead of parsing as JSON";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["route_path", "request_type", "authentication_method", "http_method", "is_static_website", "workspaced_route", "wrap_body", "raw_string"];
@@ -3696,45 +4393,62 @@ export declare const $NewHttpTrigger: {
     readonly properties: {
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when triggered";
         };
         readonly route_path: {
             readonly type: "string";
+            readonly description: "The URL route path that will trigger this endpoint (e.g., 'api/myendpoint'). Must NOT start with a /.";
         };
         readonly workspaced_route: {
             readonly type: "boolean";
+            readonly description: "If true, the route includes the workspace ID in the path";
         };
         readonly summary: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Short summary describing the purpose of this trigger";
         };
         readonly description: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Detailed description of what this trigger does";
         };
         readonly static_asset_config: {
             readonly type: "object";
+            readonly nullable: true;
+            readonly description: "Configuration for serving static assets (s3 bucket, storage path, filename)";
             readonly properties: {
                 readonly s3: {
                     readonly type: "string";
+                    readonly description: "S3 bucket path for static assets";
                 };
                 readonly storage: {
                     readonly type: "string";
+                    readonly description: "Storage path for static assets";
                 };
                 readonly filename: {
                     readonly type: "string";
+                    readonly description: "Filename for the static asset";
                 };
             };
             readonly required: readonly ["s3"];
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly http_method: {
             readonly $ref: "#/components/schemas/HttpMethod";
+            readonly description: "HTTP method (get, post, put, delete, patch) that triggers this endpoint";
         };
         readonly authentication_resource_path: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Path to the resource containing authentication configuration (for api_key, basic_http, custom_script, signature methods)";
         };
         readonly is_async: {
             readonly type: "boolean";
@@ -3742,30 +4456,38 @@ export declare const $NewHttpTrigger: {
         };
         readonly request_type: {
             readonly $ref: "#/components/schemas/HttpRequestType";
+            readonly description: "How the request is handled - 'sync' waits for result, 'async' returns job ID immediately, 'sync_sse' streams results via Server-Sent Events";
         };
         readonly authentication_method: {
             readonly $ref: "#/components/schemas/AuthenticationMethod";
+            readonly description: "How requests are authenticated - 'none' (public), 'windmill' (Windmill token), 'api_key', 'basic_http', 'custom_script', 'signature'";
         };
         readonly is_static_website: {
             readonly type: "boolean";
+            readonly description: "If true, serves static files from S3/storage instead of running a script";
         };
         readonly wrap_body: {
             readonly type: "boolean";
+            readonly description: "If true, wraps the request body in a 'body' parameter";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly raw_string: {
             readonly type: "boolean";
+            readonly description: "If true, passes the request body as a raw string instead of parsing as JSON";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["path", "script_path", "route_path", "is_flow", "authentication_method", "http_method", "is_static_website"];
@@ -3775,45 +4497,62 @@ export declare const $EditHttpTrigger: {
     readonly properties: {
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when triggered";
         };
         readonly route_path: {
             readonly type: "string";
+            readonly description: "The URL route path that will trigger this endpoint (e.g., 'api/myendpoint'). Must NOT start with a /.";
         };
         readonly summary: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Short summary describing the purpose of this trigger";
         };
         readonly description: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Detailed description of what this trigger does";
         };
         readonly workspaced_route: {
             readonly type: "boolean";
+            readonly description: "If true, the route includes the workspace ID in the path";
         };
         readonly static_asset_config: {
             readonly type: "object";
+            readonly nullable: true;
+            readonly description: "Configuration for serving static assets (s3 bucket, storage path, filename)";
             readonly properties: {
                 readonly s3: {
                     readonly type: "string";
+                    readonly description: "S3 bucket path for static assets";
                 };
                 readonly storage: {
                     readonly type: "string";
+                    readonly description: "Storage path for static assets";
                 };
                 readonly filename: {
                     readonly type: "string";
+                    readonly description: "Filename for the static asset";
                 };
             };
             readonly required: readonly ["s3"];
         };
         readonly authentication_resource_path: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Path to the resource containing authentication configuration (for api_key, basic_http, custom_script, signature methods)";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly http_method: {
             readonly $ref: "#/components/schemas/HttpMethod";
+            readonly description: "HTTP method (get, post, put, delete, patch) that triggers this endpoint";
         };
         readonly is_async: {
             readonly type: "boolean";
@@ -3821,27 +4560,35 @@ export declare const $EditHttpTrigger: {
         };
         readonly request_type: {
             readonly $ref: "#/components/schemas/HttpRequestType";
+            readonly description: "How the request is handled - 'sync' waits for result, 'async' returns job ID immediately, 'sync_sse' streams results via Server-Sent Events";
         };
         readonly authentication_method: {
             readonly $ref: "#/components/schemas/AuthenticationMethod";
+            readonly description: "How requests are authenticated - 'none' (public), 'windmill' (Windmill token), 'api_key', 'basic_http', 'custom_script', 'signature'";
         };
         readonly is_static_website: {
             readonly type: "boolean";
+            readonly description: "If true, serves static files from S3/storage instead of running a script";
         };
         readonly wrap_body: {
             readonly type: "boolean";
+            readonly description: "If true, wraps the request body in a 'body' parameter";
         };
         readonly raw_string: {
             readonly type: "boolean";
+            readonly description: "If true, passes the request body as a raw string instead of parsing as JSON";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["path", "script_path", "is_flow", "kind", "authentication_method", "http_method", "is_static_website"];
@@ -3893,6 +4640,12 @@ export declare const $TriggersCount: {
         readonly sqs_count: {
             readonly type: "number";
         };
+        readonly nextcloud_count: {
+            readonly type: "number";
+        };
+        readonly google_count: {
+            readonly type: "number";
+        };
     };
 };
 export declare const $WebsocketTrigger: {
@@ -3903,19 +4656,24 @@ export declare const $WebsocketTrigger: {
     readonly properties: {
         readonly url: {
             readonly type: "string";
+            readonly description: "The WebSocket URL to connect to (can be a static URL or computed by a runnable)";
         };
         readonly server_id: {
             readonly type: "string";
+            readonly description: "ID of the server currently handling this trigger (internal)";
         };
         readonly last_server_ping: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly description: "Timestamp of last server heartbeat (internal)";
         };
         readonly error: {
             readonly type: "string";
+            readonly description: "Last error message if the trigger failed";
         };
         readonly filters: {
             readonly type: "array";
+            readonly description: "Array of key-value filters to match incoming messages (only matching messages trigger the script)";
             readonly items: {
                 readonly type: "object";
                 readonly properties: {
@@ -3929,26 +4687,35 @@ export declare const $WebsocketTrigger: {
         };
         readonly initial_messages: {
             readonly type: "array";
+            readonly nullable: true;
+            readonly description: "Messages to send immediately after connecting (can be raw strings or computed by runnables)";
             readonly items: {
                 readonly $ref: "#/components/schemas/WebsocketTriggerInitialMessage";
             };
         };
         readonly url_runnable_args: {
+            readonly description: "Arguments to pass to the script/flow that computes the WebSocket URL";
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly nullable: true;
         };
         readonly can_return_message: {
             readonly type: "boolean";
+            readonly description: "If true, the script can return a message to send back through the WebSocket";
         };
         readonly can_return_error_result: {
             readonly type: "boolean";
+            readonly description: "If true, error results are sent back through the WebSocket";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
+            readonly description: "Arguments to pass to the error handler";
             readonly $ref: "#/components/schemas/ScriptArgs";
         };
         readonly retry: {
+            readonly description: "Retry configuration for failed executions";
             readonly $ref: "#/components/schemas/Retry";
         };
     };
@@ -3959,21 +4726,26 @@ export declare const $NewWebsocketTrigger: {
     readonly properties: {
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly url: {
             readonly type: "string";
+            readonly description: "The WebSocket URL to connect to (can be a static URL or computed by a runnable)";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly filters: {
             readonly type: "array";
+            readonly description: "Array of key-value filters to match incoming messages (only matching messages trigger the script)";
             readonly items: {
                 readonly type: "object";
                 readonly properties: {
@@ -3987,26 +4759,35 @@ export declare const $NewWebsocketTrigger: {
         };
         readonly initial_messages: {
             readonly type: "array";
+            readonly nullable: true;
+            readonly description: "Messages to send immediately after connecting (can be raw strings or computed by runnables)";
             readonly items: {
                 readonly $ref: "#/components/schemas/WebsocketTriggerInitialMessage";
             };
         };
         readonly url_runnable_args: {
+            readonly description: "Arguments to pass to the script/flow that computes the WebSocket URL";
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
         };
         readonly can_return_message: {
             readonly type: "boolean";
+            readonly description: "If true, the script can return a message to send back through the WebSocket";
         };
         readonly can_return_error_result: {
             readonly type: "boolean";
+            readonly description: "If true, error results are sent back through the WebSocket";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
+            readonly description: "Arguments to pass to the error handler";
             readonly $ref: "#/components/schemas/ScriptArgs";
         };
         readonly retry: {
+            readonly description: "Retry configuration for failed executions";
             readonly $ref: "#/components/schemas/Retry";
         };
     };
@@ -4017,18 +4798,23 @@ export declare const $EditWebsocketTrigger: {
     readonly properties: {
         readonly url: {
             readonly type: "string";
+            readonly description: "The WebSocket URL to connect to (can be a static URL or computed by a runnable)";
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly filters: {
             readonly type: "array";
+            readonly description: "Array of key-value filters to match incoming messages (only matching messages trigger the script)";
             readonly items: {
                 readonly type: "object";
                 readonly properties: {
@@ -4042,26 +4828,35 @@ export declare const $EditWebsocketTrigger: {
         };
         readonly initial_messages: {
             readonly type: "array";
+            readonly nullable: true;
+            readonly description: "Messages to send immediately after connecting (can be raw strings or computed by runnables)";
             readonly items: {
                 readonly $ref: "#/components/schemas/WebsocketTriggerInitialMessage";
             };
         };
         readonly url_runnable_args: {
+            readonly description: "Arguments to pass to the script/flow that computes the WebSocket URL";
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/ScriptArgs";
         };
         readonly can_return_message: {
             readonly type: "boolean";
+            readonly description: "If true, the script can return a message to send back through the WebSocket";
         };
         readonly can_return_error_result: {
             readonly type: "boolean";
+            readonly description: "If true, error results are sent back through the WebSocket";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
+            readonly description: "Arguments to pass to the error handler";
             readonly $ref: "#/components/schemas/ScriptArgs";
         };
         readonly retry: {
+            readonly description: "Retry configuration for failed executions";
             readonly $ref: "#/components/schemas/Retry";
         };
     };
@@ -4148,43 +4943,59 @@ export declare const $MqttTrigger: {
     readonly properties: {
         readonly mqtt_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the MQTT resource containing broker connection configuration";
         };
         readonly subscribe_topics: {
             readonly type: "array";
             readonly items: {
                 readonly $ref: "#/components/schemas/MqttSubscribeTopic";
             };
+            readonly description: "Array of MQTT topics to subscribe to, each with topic name and QoS level";
         };
         readonly v3_config: {
             readonly $ref: "#/components/schemas/MqttV3Config";
+            readonly nullable: true;
+            readonly description: "MQTT v3 specific configuration (clean_session)";
         };
         readonly v5_config: {
             readonly $ref: "#/components/schemas/MqttV5Config";
+            readonly nullable: true;
+            readonly description: "MQTT v5 specific configuration (clean_start, topic_alias_maximum, session_expiry_interval)";
         };
         readonly client_id: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "MQTT client ID for this connection";
         };
         readonly client_version: {
             readonly $ref: "#/components/schemas/MqttClientVersion";
+            readonly nullable: true;
+            readonly description: "MQTT protocol version ('v3' or 'v5')";
         };
         readonly server_id: {
             readonly type: "string";
+            readonly description: "ID of the server currently handling this trigger (internal)";
         };
         readonly last_server_ping: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly description: "Timestamp of last server heartbeat (internal)";
         };
         readonly error: {
             readonly type: "string";
+            readonly description: "Last error message if the trigger failed";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["subscribe_topics", "mqtt_resource_path"];
@@ -4194,45 +5005,61 @@ export declare const $NewMqttTrigger: {
     readonly properties: {
         readonly mqtt_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the MQTT resource containing broker connection configuration";
         };
         readonly subscribe_topics: {
             readonly type: "array";
             readonly items: {
                 readonly $ref: "#/components/schemas/MqttSubscribeTopic";
             };
+            readonly description: "Array of MQTT topics to subscribe to, each with topic name and QoS level";
         };
         readonly client_id: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "MQTT client ID for this connection";
         };
         readonly v3_config: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/MqttV3Config";
+            readonly description: "MQTT v3 specific configuration (clean_session)";
         };
         readonly v5_config: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/MqttV5Config";
+            readonly description: "MQTT v5 specific configuration (clean_start, topic_alias_maximum, session_expiry_interval)";
         };
         readonly client_version: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/MqttClientVersion";
+            readonly description: "MQTT protocol version ('v3' or 'v5')";
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["path", "script_path", "is_flow", "subscribe_topics", "mqtt_resource_path"];
@@ -4242,45 +5069,61 @@ export declare const $EditMqttTrigger: {
     readonly properties: {
         readonly mqtt_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the MQTT resource containing broker connection configuration";
         };
         readonly subscribe_topics: {
             readonly type: "array";
             readonly items: {
                 readonly $ref: "#/components/schemas/MqttSubscribeTopic";
             };
+            readonly description: "Array of MQTT topics to subscribe to, each with topic name and QoS level";
         };
         readonly client_id: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "MQTT client ID for this connection";
         };
         readonly v3_config: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/MqttV3Config";
+            readonly description: "MQTT v3 specific configuration (clean_session)";
         };
         readonly v5_config: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/MqttV5Config";
+            readonly description: "MQTT v5 specific configuration (clean_start, topic_alias_maximum, session_expiry_interval)";
         };
         readonly client_version: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/MqttClientVersion";
+            readonly description: "MQTT protocol version ('v3' or 'v5')";
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["path", "script_path", "is_flow", "enabled", "subscribe_topics", "mqtt_resource_path"];
@@ -4288,15 +5131,19 @@ export declare const $EditMqttTrigger: {
 export declare const $DeliveryType: {
     readonly type: "string";
     readonly enum: readonly ["push", "pull"];
+    readonly description: "Delivery mode for messages. 'push' for HTTP push delivery where messages are sent to a webhook endpoint, 'pull' for polling where the trigger actively fetches messages.";
 };
 export declare const $PushConfig: {
     readonly type: "object";
+    readonly description: "Configuration for push delivery mode.";
     readonly properties: {
         readonly audience: {
             readonly type: "string";
+            readonly description: "The audience claim for OIDC tokens used in push authentication.";
         };
         readonly authenticate: {
             readonly type: "boolean";
+            readonly description: "If true, push messages will include OIDC authentication tokens.";
         };
     };
     readonly required: readonly ["authenticate", "base_endpoint"];
@@ -4306,24 +5153,30 @@ export declare const $GcpTrigger: {
         readonly $ref: "#/components/schemas/TriggerExtraProperty";
     }];
     readonly type: "object";
+    readonly description: "A Google Cloud Pub/Sub trigger that executes a script or flow when messages are received.";
     readonly properties: {
         readonly gcp_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the GCP resource containing service account credentials for authentication.";
         };
         readonly topic_id: {
             readonly type: "string";
+            readonly description: "Google Cloud Pub/Sub topic ID to subscribe to.";
         };
         readonly subscription_id: {
             readonly type: "string";
+            readonly description: "Google Cloud Pub/Sub subscription ID.";
         };
         readonly server_id: {
             readonly type: "string";
+            readonly description: "ID of the server currently handling this trigger (internal use).";
         };
         readonly delivery_type: {
             readonly $ref: "#/components/schemas/DeliveryType";
         };
         readonly delivery_config: {
             readonly $ref: "#/components/schemas/PushConfig";
+            readonly nullable: true;
         };
         readonly subscription_mode: {
             readonly $ref: "#/components/schemas/SubscriptionMode";
@@ -4331,18 +5184,23 @@ export declare const $GcpTrigger: {
         readonly last_server_ping: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly description: "Timestamp of last server heartbeat (internal use).";
         };
         readonly error: {
             readonly type: "string";
+            readonly description: "Last error message if the trigger failed.";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails.";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler.";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions.";
         };
     };
     readonly required: readonly ["gcp_resource_path", "topic_id", "subscription_id", "delivery_type", "subscription_mode"];
@@ -4354,42 +5212,52 @@ export declare const $SubscriptionMode: {
 };
 export declare const $GcpTriggerData: {
     readonly type: "object";
+    readonly description: "Data for creating or updating a Google Cloud Pub/Sub trigger.";
     readonly properties: {
         readonly gcp_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the GCP resource containing service account credentials for authentication.";
         };
         readonly subscription_mode: {
             readonly $ref: "#/components/schemas/SubscriptionMode";
         };
         readonly topic_id: {
             readonly type: "string";
+            readonly description: "Google Cloud Pub/Sub topic ID to subscribe to.";
         };
         readonly subscription_id: {
             readonly type: "string";
+            readonly description: "Google Cloud Pub/Sub subscription ID.";
         };
         readonly base_endpoint: {
             readonly type: "string";
+            readonly description: "Base URL for push delivery endpoint.";
         };
         readonly delivery_type: {
             readonly $ref: "#/components/schemas/DeliveryType";
         };
         readonly delivery_config: {
+            readonly nullable: true;
             readonly $ref: "#/components/schemas/PushConfig";
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger.";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received.";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script.";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly auto_acknowledge_msg: {
             readonly type: "boolean";
+            readonly description: "If true, automatically acknowledge messages after processing.";
         };
         readonly ack_deadline: {
             readonly type: "integer";
@@ -4400,12 +5268,15 @@ export declare const $GcpTriggerData: {
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails.";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler.";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions.";
         };
     };
     readonly required: readonly ["path", "script_path", "is_flow", "gcp_resource_path", "topic_id", "subscription_mode"];
@@ -4440,37 +5311,48 @@ export declare const $SqsTrigger: {
     readonly properties: {
         readonly queue_url: {
             readonly type: "string";
+            readonly description: "The full URL of the AWS SQS queue to poll for messages";
         };
         readonly aws_auth_resource_type: {
             readonly $ref: "#/components/schemas/AwsAuthResourceType";
+            readonly description: "Authentication type - 'credentials' for access key/secret, 'oidc' for OpenID Connect";
         };
         readonly aws_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the AWS resource containing credentials or OIDC configuration";
         };
         readonly message_attributes: {
             readonly type: "array";
+            readonly nullable: true;
             readonly items: {
                 readonly type: "string";
             };
+            readonly description: "Array of SQS message attribute names to include with each message";
         };
         readonly server_id: {
             readonly type: "string";
+            readonly description: "ID of the server currently handling this trigger (internal)";
         };
         readonly last_server_ping: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly description: "Timestamp of last server heartbeat (internal)";
         };
         readonly error: {
             readonly type: "string";
+            readonly description: "Last error message if the trigger failed";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["queue_url", "aws_resource_path", "aws_auth_resource_type"];
@@ -4534,39 +5416,50 @@ export declare const $NewSqsTrigger: {
     readonly properties: {
         readonly queue_url: {
             readonly type: "string";
+            readonly description: "The full URL of the AWS SQS queue to poll for messages";
         };
         readonly aws_auth_resource_type: {
             readonly $ref: "#/components/schemas/AwsAuthResourceType";
+            readonly description: "Authentication type - 'credentials' for access key/secret, 'oidc' for OpenID Connect";
         };
         readonly aws_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the AWS resource containing credentials or OIDC configuration";
         };
         readonly message_attributes: {
             readonly type: "array";
+            readonly nullable: true;
             readonly items: {
                 readonly type: "string";
             };
+            readonly description: "Array of SQS message attribute names to include with each message";
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["queue_url", "aws_resource_path", "path", "script_path", "is_flow", "aws_auth_resource_type"];
@@ -4576,39 +5469,50 @@ export declare const $EditSqsTrigger: {
     readonly properties: {
         readonly queue_url: {
             readonly type: "string";
+            readonly description: "The full URL of the AWS SQS queue to poll for messages";
         };
         readonly aws_auth_resource_type: {
             readonly $ref: "#/components/schemas/AwsAuthResourceType";
+            readonly description: "Authentication type - 'credentials' for access key/secret, 'oidc' for OpenID Connect";
         };
         readonly aws_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the AWS resource containing credentials or OIDC configuration";
         };
         readonly message_attributes: {
             readonly type: "array";
+            readonly nullable: true;
             readonly items: {
                 readonly type: "string";
             };
+            readonly description: "Array of SQS message attribute names to include with each message";
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["queue_url", "aws_resource_path", "path", "script_path", "is_flow", "enabled", "aws_auth_resource_type"];
@@ -4713,31 +5617,40 @@ export declare const $PostgresTrigger: {
     readonly properties: {
         readonly postgres_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the PostgreSQL resource containing connection configuration";
         };
         readonly publication_name: {
             readonly type: "string";
+            readonly description: "Name of the PostgreSQL publication to subscribe to for change data capture";
         };
         readonly server_id: {
             readonly type: "string";
+            readonly description: "ID of the server currently handling this trigger (internal)";
         };
         readonly replication_slot_name: {
             readonly type: "string";
+            readonly description: "Name of the PostgreSQL logical replication slot to use";
         };
         readonly error: {
             readonly type: "string";
+            readonly description: "Last error message if the trigger failed";
         };
         readonly last_server_ping: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly description: "Timestamp of last server heartbeat (internal)";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["postgres_resource_path", "replication_slot_name", "publication_name"];
@@ -4747,36 +5660,46 @@ export declare const $NewPostgresTrigger: {
     readonly properties: {
         readonly replication_slot_name: {
             readonly type: "string";
+            readonly description: "Name of the PostgreSQL logical replication slot to use";
         };
         readonly publication_name: {
             readonly type: "string";
+            readonly description: "Name of the PostgreSQL publication to subscribe to for change data capture";
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when database changes are detected";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly postgres_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the PostgreSQL resource containing connection configuration";
         };
         readonly publication: {
             readonly $ref: "#/components/schemas/PublicationData";
+            readonly description: "Configuration for creating/managing the publication (tables, operations)";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["path", "script_path", "is_flow", "enabled", "postgres_resource_path"];
@@ -4786,36 +5709,46 @@ export declare const $EditPostgresTrigger: {
     readonly properties: {
         readonly replication_slot_name: {
             readonly type: "string";
+            readonly description: "Name of the PostgreSQL logical replication slot to use";
         };
         readonly publication_name: {
             readonly type: "string";
+            readonly description: "Name of the PostgreSQL publication to subscribe to for change data capture";
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when database changes are detected";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly postgres_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the PostgreSQL resource containing connection configuration";
         };
         readonly publication: {
             readonly $ref: "#/components/schemas/PublicationData";
+            readonly description: "Configuration for creating/managing the publication (tables, operations)";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["path", "script_path", "is_flow", "enabled", "postgres_resource_path", "publication_name", "replication_slot_name"];
@@ -4828,112 +5761,178 @@ export declare const $KafkaTrigger: {
     readonly properties: {
         readonly kafka_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the Kafka resource containing connection configuration";
         };
         readonly group_id: {
             readonly type: "string";
+            readonly description: "Kafka consumer group ID for this trigger";
         };
         readonly topics: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
             };
+            readonly description: "Array of Kafka topic names to subscribe to";
+        };
+        readonly filters: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly key: {
+                        readonly type: "string";
+                    };
+                    readonly value: {};
+                };
+                readonly required: readonly ["key", "value"];
+            };
         };
         readonly server_id: {
             readonly type: "string";
+            readonly description: "ID of the server currently handling this trigger (internal)";
         };
         readonly last_server_ping: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly description: "Timestamp of last server heartbeat (internal)";
         };
         readonly error: {
             readonly type: "string";
+            readonly description: "Last error message if the trigger failed";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
-    readonly required: readonly ["kafka_resource_path", "group_id", "topics"];
+    readonly required: readonly ["kafka_resource_path", "group_id", "topics", "filters"];
 };
 export declare const $NewKafkaTrigger: {
     readonly type: "object";
     readonly properties: {
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly kafka_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the Kafka resource containing connection configuration";
         };
         readonly group_id: {
             readonly type: "string";
+            readonly description: "Kafka consumer group ID for this trigger";
         };
         readonly topics: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
             };
+            readonly description: "Array of Kafka topic names to subscribe to";
+        };
+        readonly filters: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly key: {
+                        readonly type: "string";
+                    };
+                    readonly value: {};
+                };
+                readonly required: readonly ["key", "value"];
+            };
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
-    readonly required: readonly ["path", "script_path", "is_flow", "kafka_resource_path", "group_id", "topics"];
+    readonly required: readonly ["path", "script_path", "is_flow", "kafka_resource_path", "group_id", "topics", "filters"];
 };
 export declare const $EditKafkaTrigger: {
     readonly type: "object";
     readonly properties: {
         readonly kafka_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the Kafka resource containing connection configuration";
         };
         readonly group_id: {
             readonly type: "string";
+            readonly description: "Kafka consumer group ID for this trigger";
         };
         readonly topics: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
             };
+            readonly description: "Array of Kafka topic names to subscribe to";
+        };
+        readonly filters: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly key: {
+                        readonly type: "string";
+                    };
+                    readonly value: {};
+                };
+                readonly required: readonly ["key", "value"];
+            };
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
-    readonly required: readonly ["path", "script_path", "kafka_resource_path", "group_id", "topics", "is_flow"];
+    readonly required: readonly ["path", "script_path", "kafka_resource_path", "group_id", "topics", "filters", "is_flow"];
 };
 export declare const $NatsTrigger: {
     readonly allOf: readonly [{
@@ -4943,40 +5942,53 @@ export declare const $NatsTrigger: {
     readonly properties: {
         readonly nats_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the NATS resource containing connection configuration";
         };
         readonly use_jetstream: {
             readonly type: "boolean";
+            readonly description: "If true, uses NATS JetStream for durable message delivery";
         };
         readonly stream_name: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "JetStream stream name (required when use_jetstream is true)";
         };
         readonly consumer_name: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "JetStream consumer name (required when use_jetstream is true)";
         };
         readonly subjects: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
             };
+            readonly description: "Array of NATS subjects to subscribe to";
         };
         readonly server_id: {
             readonly type: "string";
+            readonly description: "ID of the server currently handling this trigger (internal)";
         };
         readonly last_server_ping: {
             readonly type: "string";
             readonly format: "date-time";
+            readonly description: "Timestamp of last server heartbeat (internal)";
         };
         readonly error: {
             readonly type: "string";
+            readonly description: "Last error message if the trigger failed";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["nats_resource_path", "use_jetstream", "subjects"];
@@ -4986,42 +5998,55 @@ export declare const $NewNatsTrigger: {
     readonly properties: {
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly nats_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the NATS resource containing connection configuration";
         };
         readonly use_jetstream: {
             readonly type: "boolean";
+            readonly description: "If true, uses NATS JetStream for durable message delivery";
         };
         readonly stream_name: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "JetStream stream name (required when use_jetstream is true)";
         };
         readonly consumer_name: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "JetStream consumer name (required when use_jetstream is true)";
         };
         readonly subjects: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
             };
+            readonly description: "Array of NATS subjects to subscribe to";
         };
         readonly mode: {
             readonly $ref: "#/components/schemas/TriggerMode";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["path", "script_path", "is_flow", "nats_resource_path", "use_jetstream", "subjects"];
@@ -5031,39 +6056,52 @@ export declare const $EditNatsTrigger: {
     readonly properties: {
         readonly nats_resource_path: {
             readonly type: "string";
+            readonly description: "Path to the NATS resource containing connection configuration";
         };
         readonly use_jetstream: {
             readonly type: "boolean";
+            readonly description: "If true, uses NATS JetStream for durable message delivery";
         };
         readonly stream_name: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "JetStream stream name (required when use_jetstream is true)";
         };
         readonly consumer_name: {
             readonly type: "string";
+            readonly nullable: true;
+            readonly description: "JetStream consumer name (required when use_jetstream is true)";
         };
         readonly subjects: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
             };
+            readonly description: "Array of NATS subjects to subscribe to";
         };
         readonly path: {
             readonly type: "string";
+            readonly description: "The unique path identifier for this trigger";
         };
         readonly script_path: {
             readonly type: "string";
+            readonly description: "Path to the script or flow to execute when a message is received";
         };
         readonly is_flow: {
             readonly type: "boolean";
+            readonly description: "True if script_path points to a flow, false if it points to a script";
         };
         readonly error_handler_path: {
             readonly type: "string";
+            readonly description: "Path to a script or flow to run when the triggered job fails";
         };
         readonly error_handler_args: {
             readonly $ref: "#/components/schemas/ScriptArgs";
+            readonly description: "Arguments to pass to the error handler";
         };
         readonly retry: {
             readonly $ref: "#/components/schemas/Retry";
+            readonly description: "Retry configuration for failed executions";
         };
     };
     readonly required: readonly ["path", "script_path", "nats_resource_path", "use_jetstream", "subjects", "is_flow"];
@@ -5334,6 +6372,9 @@ export declare const $WorkerPing: {
         readonly job_isolation: {
             readonly type: "string";
         };
+        readonly native_mode: {
+            readonly type: "boolean";
+        };
     };
     readonly required: readonly ["worker", "worker_instance", "ping_at", "started_at", "ip", "jobs_executed", "worker_group", "wm_version"];
 };
@@ -5889,9 +6930,7 @@ export declare const $AppWithLastVersion: {
             readonly type: "string";
             readonly format: "date-time";
         };
-        readonly value: {
-            readonly type: "object";
-        };
+        readonly value: {};
         readonly policy: {
             readonly $ref: "#/components/schemas/Policy";
         };
@@ -5908,8 +6947,14 @@ export declare const $AppWithLastVersion: {
         readonly custom_path: {
             readonly type: "string";
         };
+        readonly raw_app: {
+            readonly type: "boolean";
+        };
+        readonly bundle_secret: {
+            readonly type: "string";
+        };
     };
-    readonly required: readonly ["id", "workspace_id", "path", "summary", "versions", "created_by", "created_at", "value", "policy", "execution_mode", "extra_perms"];
+    readonly required: readonly ["id", "workspace_id", "path", "summary", "versions", "created_by", "created_at", "value", "policy", "execution_mode", "extra_perms", "raw_app"];
 };
 export declare const $AppWithLastVersionWDraft: {
     readonly allOf: readonly [{
@@ -6098,6 +7143,9 @@ export declare const $DucklakeSettings: {
                         };
                         readonly required: readonly ["path"];
                     };
+                    readonly extra_args: {
+                        readonly type: "string";
+                    };
                 };
             };
         };
@@ -6131,6 +7179,34 @@ export declare const $DataTableSettings: {
         };
     };
 };
+export declare const $DataTableSchema: {
+    readonly type: "object";
+    readonly required: readonly ["datatable_name", "schemas"];
+    readonly properties: {
+        readonly datatable_name: {
+            readonly type: "string";
+        };
+        readonly schemas: {
+            readonly type: "object";
+            readonly description: "Hierarchical schema: schema_name -> table_name -> column_name -> compact_type (e.g. 'int4', 'text?', 'int4?=0')";
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly description: "Tables in this schema";
+                readonly additionalProperties: {
+                    readonly type: "object";
+                    readonly description: "Columns in this table";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                        readonly description: "Compact type: 'type[?][=default]' where ? means nullable";
+                    };
+                };
+            };
+        };
+        readonly error: {
+            readonly type: "string";
+        };
+    };
+};
 export declare const $DynamicInputData: {
     readonly type: "object";
     readonly properties: {
@@ -6510,11 +7586,28 @@ export declare const $GlobalSetting: {
         readonly name: {
             readonly type: "string";
         };
-        readonly value: {
+        readonly value: {};
+    };
+    readonly required: readonly ["name", "value"];
+};
+export declare const $InstanceConfig: {
+    readonly type: "object";
+    readonly description: "Unified instance configuration combining global settings and worker group configs";
+    readonly properties: {
+        readonly global_settings: {
+            readonly type: "object";
+            readonly description: "Global settings keyed by setting name. Known fields include base_url, license_key, retention_period_secs, smtp_settings, otel, etc. Unknown fields are preserved as-is.\n";
+            readonly additionalProperties: true;
+        };
+        readonly worker_configs: {
             readonly type: "object";
+            readonly description: "Worker group configurations keyed by group name (e.g. \"default\", \"gpu\"). Each value contains worker_tags, init_bash, autoscaling, etc.\n";
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+            };
         };
     };
-    readonly required: readonly ["name", "value"];
 };
 export declare const $Config: {
     readonly type: "object";
@@ -6749,7 +7842,7 @@ export declare const $WorkspaceItemDiff: {
     readonly properties: {
         readonly kind: {
             readonly type: "string";
-            readonly enum: readonly ["script", "flow", "app", "resource", "variable"];
+            readonly enum: readonly ["script", "flow", "app", "resource", "variable", "resource_type"];
             readonly description: "Type of the item";
         };
         readonly path: {
@@ -6780,7 +7873,7 @@ export declare const $WorkspaceItemDiff: {
 };
 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 required: readonly ["total_diffs", "total_ahead", "total_behind", "scripts_changed", "flows_changed", "apps_changed", "resources_changed", "variables_changed", "resource_types_changed", "folders_changed", "conflicts"];
     readonly properties: {
         readonly total_diffs: {
             readonly type: "integer";
@@ -6814,6 +7907,14 @@ export declare const $CompareSummary: {
             readonly type: "integer";
             readonly description: "Number of variables with differences";
         };
+        readonly resource_types_changed: {
+            readonly type: "integer";
+            readonly description: "Number of resource types with differences";
+        };
+        readonly folders_changed: {
+            readonly type: "integer";
+            readonly description: "Number of folders with differences";
+        };
         readonly conflicts: {
             readonly type: "integer";
             readonly description: "Number of items that are both ahead and behind (conflicts)";
@@ -6972,11 +8073,12 @@ export declare const $TeamsChannel: {
 };
 export declare const $AssetUsageKind: {
     readonly type: "string";
-    readonly enum: readonly ["script", "flow"];
+    readonly enum: readonly ["script", "flow", "job"];
 };
 export declare const $AssetUsageAccessType: {
     readonly type: "string";
     readonly enum: readonly ["r", "w", "rw"];
+    readonly nullable: true;
 };
 export declare const $AssetKind: {
     readonly type: "string";
@@ -6994,3 +8096,340 @@ export declare const $Asset: {
     };
     readonly required: readonly ["path", "kind"];
 };
+export declare const $ProtectionRuleset: {
+    readonly type: "object";
+    readonly description: "A workspace protection rule defining restrictions and bypass permissions";
+    readonly required: readonly ["name", "rules", "bypass_groups", "bypass_users"];
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Unique name for the protection rule";
+            readonly example: "Production Protection";
+        };
+        readonly workspace_id: {
+            readonly type: "string";
+        };
+        readonly rules: {
+            readonly $ref: "#/components/schemas/ProtectionRules";
+        };
+        readonly bypass_groups: {
+            readonly $ref: "#/components/schemas/RuleBypasserGroups";
+        };
+        readonly bypass_users: {
+            readonly $ref: "#/components/schemas/RuleBypasserUsers";
+        };
+    };
+};
+export declare const $ProtectionRules: {
+    readonly type: "array";
+    readonly description: "Configuration of protection restrictions";
+    readonly items: {
+        readonly $ref: "#/components/schemas/ProtectionRuleKind";
+    };
+};
+export declare const $ProtectionRuleKind: {
+    readonly type: "string";
+    readonly enum: readonly ["DisableDirectDeployment", "DisableWorkspaceForking"];
+};
+export declare const $RuleBypasserGroups: {
+    readonly type: "array";
+    readonly description: "Groups that can bypass this ruleset";
+    readonly items: {
+        readonly type: "string";
+    };
+};
+export declare const $RuleBypasserUsers: {
+    readonly type: "array";
+    readonly description: "Users that can bypass this ruleset";
+    readonly items: {
+        readonly type: "string";
+    };
+};
+export declare const $NativeServiceName: {
+    readonly type: "string";
+    readonly enum: readonly ["nextcloud", "google"];
+};
+export declare const $NativeTrigger: {
+    readonly type: "object";
+    readonly description: "A native trigger stored in Windmill";
+    readonly properties: {
+        readonly external_id: {
+            readonly type: "string";
+            readonly description: "The unique identifier from the external service";
+        };
+        readonly workspace_id: {
+            readonly type: "string";
+            readonly description: "The workspace this trigger belongs to";
+        };
+        readonly service_name: {
+            readonly $ref: "#/components/schemas/NativeServiceName";
+        };
+        readonly script_path: {
+            readonly type: "string";
+            readonly description: "The path to the script or flow that will be triggered";
+        };
+        readonly is_flow: {
+            readonly type: "boolean";
+            readonly description: "Whether the trigger targets a flow (true) or a script (false)";
+        };
+        readonly service_config: {
+            readonly type: "object";
+            readonly description: "Configuration for the trigger including event_type and service_config";
+            readonly additionalProperties: true;
+        };
+        readonly error: {
+            readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Error message if the trigger is in an error state";
+        };
+    };
+    readonly required: readonly ["external_id", "workspace_id", "service_name", "script_path", "is_flow", "service_config"];
+};
+export declare const $NativeTriggerWithExternal: {
+    readonly type: "object";
+    readonly description: "Full trigger response containing both Windmill data and external service data";
+    readonly properties: {
+        readonly external_id: {
+            readonly type: "string";
+            readonly description: "The unique identifier from the external service";
+        };
+        readonly workspace_id: {
+            readonly type: "string";
+            readonly description: "The workspace this trigger belongs to";
+        };
+        readonly service_name: {
+            readonly $ref: "#/components/schemas/NativeServiceName";
+        };
+        readonly script_path: {
+            readonly type: "string";
+            readonly description: "The path to the script or flow that will be triggered";
+        };
+        readonly is_flow: {
+            readonly type: "boolean";
+            readonly description: "Whether the trigger targets a flow (true) or a script (false)";
+        };
+        readonly service_config: {
+            readonly type: "object";
+            readonly description: "Configuration for the trigger including event_type and service_config";
+            readonly additionalProperties: true;
+        };
+        readonly error: {
+            readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Error message if the trigger is in an error state";
+        };
+        readonly external_data: {
+            readonly type: "object";
+            readonly description: "Configuration data from the external service";
+            readonly additionalProperties: true;
+        };
+    };
+    readonly required: readonly ["external_id", "workspace_id", "service_name", "script_path", "is_flow", "service_config", "external_data"];
+};
+export declare const $WorkspaceIntegrations: {
+    readonly type: "object";
+    readonly properties: {
+        readonly service_name: {
+            readonly $ref: "#/components/schemas/NativeServiceName";
+        };
+        readonly oauth_data: {
+            readonly nullable: true;
+            readonly $ref: "#/components/schemas/WorkspaceOAuthConfig";
+        };
+        readonly resource_path: {
+            readonly type: "string";
+            readonly nullable: true;
+            readonly description: "Path to the resource storing the OAuth token";
+        };
+    };
+    readonly required: readonly ["service_name"];
+};
+export declare const $WorkspaceOAuthConfig: {
+    readonly type: "object";
+    readonly properties: {
+        readonly client_id: {
+            readonly type: "string";
+            readonly description: "The OAuth client ID for the workspace";
+        };
+        readonly client_secret: {
+            readonly type: "string";
+            readonly description: "The OAuth client secret for the workspace";
+        };
+        readonly base_url: {
+            readonly type: "string";
+            readonly format: "uri";
+            readonly description: "The base URL of the workspace";
+        };
+        readonly redirect_uri: {
+            readonly type: "string";
+            readonly format: "uri";
+            readonly description: "The OAuth redirect URI";
+        };
+    };
+    readonly required: readonly ["client_id", "client_secret", "base_url", "redirect_uri"];
+};
+export declare const $WebhookEvent: {
+    readonly type: "object";
+    readonly properties: {
+        readonly type: {
+            readonly type: "string";
+            readonly enum: readonly ["webhook"];
+        };
+        readonly request_type: {
+            readonly $ref: "#/components/schemas/WebhookRequestType";
+        };
+    };
+    readonly required: readonly ["type", "request_type"];
+};
+export declare const $WebhookRequestType: {
+    readonly type: "string";
+    readonly description: "The type of webhook request (define possible values here)";
+    readonly enum: readonly ["async", "sync"];
+};
+export declare const $RedirectUri: {
+    readonly type: "object";
+    readonly properties: {
+        readonly redirect_uri: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["redirect_uri"];
+};
+export declare const $NativeTriggerData: {
+    readonly type: "object";
+    readonly description: "Data for creating or updating a native trigger";
+    readonly properties: {
+        readonly script_path: {
+            readonly type: "string";
+            readonly description: "The path to the script or flow that will be triggered";
+        };
+        readonly is_flow: {
+            readonly type: "boolean";
+            readonly description: "Whether the trigger targets a flow (true) or a script (false)";
+        };
+        readonly service_config: {
+            readonly type: "object";
+            readonly description: "Service-specific configuration (e.g., event types, filters)";
+            readonly additionalProperties: true;
+        };
+    };
+    readonly required: readonly ["script_path", "is_flow", "service_config"];
+};
+export declare const $CreateTriggerResponse: {
+    readonly type: "object";
+    readonly description: "Response returned when a native trigger is created";
+    readonly properties: {
+        readonly external_id: {
+            readonly type: "string";
+            readonly description: "The external ID of the created trigger from the external service";
+        };
+    };
+    readonly required: readonly ["external_id"];
+};
+export declare const $SyncResult: {
+    readonly type: "object";
+    readonly properties: {
+        readonly already_in_sync: {
+            readonly type: "boolean";
+        };
+        readonly added_count: {
+            readonly type: "integer";
+        };
+        readonly added_triggers: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly total_external: {
+            readonly type: "integer";
+        };
+        readonly total_windmill: {
+            readonly type: "integer";
+        };
+    };
+    readonly required: readonly ["already_in_sync", "added_count", "added_triggers", "total_external", "total_windmill"];
+};
+export declare const $NextCloudEventType: {
+    readonly type: "object";
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+        };
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+        };
+        readonly category: {
+            readonly type: "string";
+        };
+        readonly path: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["id", "name", "path"];
+};
+export declare const $GoogleCalendarEntry: {
+    readonly type: "object";
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+        };
+        readonly summary: {
+            readonly type: "string";
+        };
+        readonly primary: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+    };
+    readonly required: readonly ["id", "summary"];
+};
+export declare const $GoogleDriveFile: {
+    readonly type: "object";
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+        };
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly mime_type: {
+            readonly type: "string";
+        };
+        readonly is_folder: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+    };
+    readonly required: readonly ["id", "name", "mime_type"];
+};
+export declare const $GoogleDriveFilesResponse: {
+    readonly type: "object";
+    readonly properties: {
+        readonly files: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/GoogleDriveFile";
+            };
+        };
+        readonly next_page_token: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["files"];
+};
+export declare const $SharedDriveEntry: {
+    readonly type: "object";
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+        };
+        readonly name: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["id", "name"];
+};