@prostgles/prostgles 2.3.6-dev.1786615880 → 2.3.6-dev.1786992729

package/dist/server/src/serverFunctions/stateServerFunctions.d.ts

@@ -0,0 +1,3823 @@
+import type { DBGeneratedSchema } from "../../../common/DBGeneratedSchema";
+import type { DBS } from "../index";
+export type Users = Required<DBGeneratedSchema["users"]["columns"]>;
+export type Connections = Required<DBGeneratedSchema["connections"]["columns"]>;
+import type { AnyObject } from "prostgles-types";
+export declare const stateServerFunctions: {
+    anyUser: {
+        readonly userFilter: {};
+        readonly functions: {
+            readonly startConnection: {
+                input?: {
+                    connectionId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    socketPath: string;
+                    socketUrl: string | undefined;
+                } | undefined>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+        };
+    };
+    adminMethods: {
+        readonly userFilter: {
+            readonly type: "admin";
+        };
+        readonly functions: {
+            readonly startAgenticWorkflow: {
+                input?: Pick<{
+                    readonly chatId: "integer";
+                    readonly messageId: "string";
+                    readonly workflowId: "integer";
+                    readonly name: "string";
+                    readonly workflowTs: "string";
+                    readonly autoApproveAllTools: "boolean";
+                    readonly containerConfiguration: {
+                        readonly type: {
+                            readonly timeout: {
+                                readonly optional: false;
+                                readonly type: "integer";
+                                readonly description: "Maximum time in milliseconds the container will be allowed to run. Defaults to 30000. ";
+                            };
+                            readonly cpus: {
+                                readonly optional: true;
+                                readonly type: "string";
+                                readonly description: "CPU limit (e.g., '0.5', '1'). Defaults to 1";
+                            };
+                            readonly memory: {
+                                readonly optional: true;
+                                readonly type: "string";
+                                readonly description: "Memory limit (e.g., '512m', '1g'). Defaults to 512m";
+                            };
+                            readonly readOnly: {
+                                readonly optional: true;
+                                readonly type: "boolean";
+                                readonly description: "Whether to mount the filesystem as read-only. Defaults to true";
+                            };
+                            readonly internetAccess: {
+                                readonly optional: true;
+                                readonly enum: readonly ["none", "bridge", "host"];
+                                readonly description: "Whether the container should have access to the internet. Defaults to 'none'. Do not use 'host' unless it is strictly necessary, as it can be a security risk.";
+                            };
+                        };
+                    };
+                    readonly executionMode: {
+                        readonly enum: readonly ["series", "parallel"];
+                    };
+                    readonly databaseAccessDefinitions: {
+                        readonly optional: true;
+                        readonly oneOfType: readonly [{
+                            readonly mode: {
+                                readonly enum: readonly ["execute_readonly_sql"];
+                            };
+                        }, {
+                            readonly mode: {
+                                readonly enum: readonly ["execute_sql"];
+                            };
+                            readonly allowedCommands: {
+                                readonly optional: true;
+                                readonly record: {
+                                    readonly partial: true;
+                                    readonly keysEnum: readonly ["select", "insert", "update", "delete"];
+                                    readonly values: {
+                                        readonly enum: readonly [1];
+                                    };
+                                };
+                            };
+                        }, {
+                            readonly mode: {
+                                readonly enum: readonly ["custom"];
+                            };
+                            readonly tablePermissions: {
+                                readonly title: "Tables";
+                                readonly description: "Tables the assistant can access";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly type: {
+                                            readonly select: {
+                                                readonly oneOf: readonly [{
+                                                    readonly enum: readonly [true];
+                                                }, {
+                                                    readonly type: {
+                                                        readonly forcedFilter: {
+                                                            readonly optional: true;
+                                                            readonly oneOfType: readonly [{
+                                                                readonly $and: "any[]";
+                                                            }, {
+                                                                readonly $or: "any[]";
+                                                            }];
+                                                        };
+                                                        readonly fields: {
+                                                            readonly oneOf: readonly [{
+                                                                readonly enum: readonly ["*"];
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [1];
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [0];
+                                                                    };
+                                                                };
+                                                            }];
+                                                        };
+                                                    };
+                                                }];
+                                                readonly optional: true;
+                                            };
+                                            readonly update: {
+                                                readonly oneOf: readonly [{
+                                                    readonly enum: readonly [true];
+                                                }, {
+                                                    readonly type: {
+                                                        readonly forcedFilter: {
+                                                            readonly optional: true;
+                                                            readonly oneOfType: readonly [{
+                                                                readonly $and: "any[]";
+                                                            }, {
+                                                                readonly $or: "any[]";
+                                                            }];
+                                                        };
+                                                        readonly fields: {
+                                                            readonly oneOf: readonly [{
+                                                                readonly enum: readonly ["*"];
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [1];
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [0];
+                                                                    };
+                                                                };
+                                                            }];
+                                                        };
+                                                    };
+                                                }];
+                                                readonly optional: true;
+                                            };
+                                            readonly insert: {
+                                                readonly oneOf: readonly [{
+                                                    readonly enum: readonly [true];
+                                                }, {
+                                                    readonly type: {
+                                                        readonly fields: {
+                                                            readonly oneOf: readonly [{
+                                                                readonly enum: readonly ["*"];
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [1];
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [0];
+                                                                    };
+                                                                };
+                                                            }];
+                                                        };
+                                                    };
+                                                }];
+                                                readonly optional: true;
+                                            };
+                                            readonly delete: {
+                                                readonly oneOf: readonly [{
+                                                    readonly enum: readonly [true];
+                                                }, {
+                                                    readonly type: {
+                                                        readonly forcedFilter: {
+                                                            readonly optional: true;
+                                                            readonly oneOfType: readonly [{
+                                                                readonly $and: "any[]";
+                                                            }, {
+                                                                readonly $or: "any[]";
+                                                            }];
+                                                        };
+                                                    };
+                                                }];
+                                                readonly optional: true;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            readonly ddlStatements: {
+                                readonly description: "Table create statements";
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                        }];
+                    };
+                    readonly orchestrationTools: {
+                        readonly optional: true;
+                        readonly oneOf: readonly [{
+                            readonly enum: readonly [undefined];
+                        }, {
+                            readonly record: {
+                                readonly partial: true;
+                                readonly values: {
+                                    readonly record: {
+                                        readonly partial: true;
+                                        readonly values: {
+                                            readonly enum: readonly [1];
+                                        };
+                                    };
+                                };
+                            };
+                        }];
+                    };
+                    readonly agentDefinitions: {
+                        optional: boolean;
+                        record: {
+                            values: {
+                                type: {
+                                    readonly prompt: {
+                                        readonly type: "string";
+                                    };
+                                    readonly modelName: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                        readonly description: "The name of the LLM model to use for this agent. If not provided, the default model will be used.";
+                                    };
+                                    readonly maxCostUSD: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                        readonly description: "The maximum cost in USD that this agent is allowed to incur.";
+                                    };
+                                    readonly maxIterations: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                        readonly description: "The maximum number of iterations this agent is allowed to run.";
+                                    };
+                                    readonly tools: {
+                                        readonly optional: true;
+                                        readonly record: {
+                                            readonly partial: true;
+                                            readonly values: {
+                                                readonly record: {
+                                                    readonly partial: true;
+                                                    readonly values: {
+                                                        readonly enum: readonly [1];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                    readonly mcpServerConfigs: {
+                                        readonly optional: true;
+                                        readonly description: "SYSTEM ONLY — DO NOT SPECIFY: Do not generate, invent, or prompt the user for configuration IDs. This field is automatically injected by the host runtime when a tool requires user-provided MCP server authorization.";
+                                        readonly record: {
+                                            readonly partial: true;
+                                            readonly values: {
+                                                readonly type: {
+                                                    readonly configId: {
+                                                        readonly type: "number";
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                    readonly maxTokens: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                    };
+                                    readonly temperature: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                    };
+                                    readonly outputSchema: {
+                                        readonly record: {
+                                            readonly values: {
+                                                readonly oneOf: readonly [{
+                                                    readonly type: {
+                                                        readonly optional: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly nullable: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly type: {
+                                                            readonly enum: readonly ["string", "number", "boolean", "unknown", ...("string[]" | "number[]" | "boolean[]" | "unknown[]")[]];
+                                                        };
+                                                    };
+                                                }, {
+                                                    readonly type: {
+                                                        readonly optional: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly nullable: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly type: {
+                                                            readonly record: {
+                                                                readonly values: {
+                                                                    readonly type: {
+                                                                        readonly optional: {
+                                                                            readonly type: "boolean";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly nullable: {
+                                                                            readonly type: "boolean";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly type: {
+                                                                            readonly enum: readonly ["string", "number", "boolean", "unknown", ...("string[]" | "number[]" | "boolean[]" | "unknown[]")[]];
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                }, {
+                                                    readonly type: {
+                                                        readonly optional: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly arrayOfType: {
+                                                            readonly record: {
+                                                                readonly values: {
+                                                                    readonly type: {
+                                                                        readonly optional: {
+                                                                            readonly type: "boolean";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly nullable: {
+                                                                            readonly type: "boolean";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly type: {
+                                                                            readonly enum: readonly ["string", "number", "boolean", "unknown", ...("string[]" | "number[]" | "boolean[]" | "unknown[]")[]];
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                }];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    readonly userInput: {
+                        readonly optional: true;
+                        readonly description: string;
+                        readonly record: {
+                            readonly values: {
+                                readonly oneOfType: readonly [{
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-column-value"];
+                                    };
+                                    readonly tableName: "string";
+                                    readonly columnName: "string";
+                                    readonly defaultValue: {
+                                        readonly type: "any";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-column-values"];
+                                    };
+                                    readonly tableName: "string";
+                                    readonly columnName: "string";
+                                    readonly defaultValue: {
+                                        readonly type: "any[]";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-filter"];
+                                    };
+                                    readonly tableName: "string";
+                                    readonly defaultValue: {
+                                        readonly record: {
+                                            readonly values: "any";
+                                        };
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-column"];
+                                    };
+                                    readonly tableName: "string";
+                                    readonly defaultValue: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-name"];
+                                    };
+                                    readonly defaultValue: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-and-column"];
+                                    };
+                                    readonly defaultValue: {
+                                        readonly type: {
+                                            readonly tableName: "string";
+                                            readonly columnName: "string";
+                                        };
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["enum"];
+                                    };
+                                    readonly values: "string[]";
+                                    readonly defaultValue: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["custom"];
+                                    };
+                                    readonly dataType: {
+                                        readonly enum: readonly ["string", "number", "boolean", "Date"];
+                                    };
+                                    readonly defaultValue: {
+                                        readonly type: "unknown";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["folder-path", "file-path", "file-or-folder-path"];
+                                    };
+                                    readonly accessMode: {
+                                        readonly enum: readonly ["read", "read-write"];
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["folder-paths", "file-paths", "file-or-folder-paths"];
+                                    };
+                                    readonly accessMode: {
+                                        readonly enum: readonly ["read", "read-write"];
+                                    };
+                                }];
+                            };
+                        };
+                    };
+                    readonly userInputValue: {
+                        readonly record: {
+                            readonly values: {
+                                readonly type: "unknown";
+                            };
+                        };
+                    };
+                    readonly newTables: {
+                        readonly optional: true;
+                        readonly arrayOfType: {
+                            readonly name: "string";
+                            readonly schema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly columns: {
+                                readonly arrayOfType: {
+                                    readonly name: "string";
+                                    readonly dataType: "string";
+                                    readonly nullable: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly isPrimaryKey: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, "name" | "userInput" | "userInputValue" | "containerConfiguration" | "databaseAccessDefinitions" | "agentDefinitions" | "chatId" | "workflowId" | "autoApproveAllTools" | "messageId" | "newTables" | "orchestrationTools" | "workflowTs" | "executionMode"> | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<Pick<{
+                    readonly chatId: "integer";
+                    readonly messageId: "string";
+                    readonly workflowId: "integer";
+                    readonly name: "string";
+                    readonly workflowTs: "string";
+                    readonly autoApproveAllTools: "boolean";
+                    readonly containerConfiguration: {
+                        readonly type: {
+                            readonly timeout: {
+                                readonly optional: false;
+                                readonly type: "integer";
+                                readonly description: "Maximum time in milliseconds the container will be allowed to run. Defaults to 30000. ";
+                            };
+                            readonly cpus: {
+                                readonly optional: true;
+                                readonly type: "string";
+                                readonly description: "CPU limit (e.g., '0.5', '1'). Defaults to 1";
+                            };
+                            readonly memory: {
+                                readonly optional: true;
+                                readonly type: "string";
+                                readonly description: "Memory limit (e.g., '512m', '1g'). Defaults to 512m";
+                            };
+                            readonly readOnly: {
+                                readonly optional: true;
+                                readonly type: "boolean";
+                                readonly description: "Whether to mount the filesystem as read-only. Defaults to true";
+                            };
+                            readonly internetAccess: {
+                                readonly optional: true;
+                                readonly enum: readonly ["none", "bridge", "host"];
+                                readonly description: "Whether the container should have access to the internet. Defaults to 'none'. Do not use 'host' unless it is strictly necessary, as it can be a security risk.";
+                            };
+                        };
+                    };
+                    readonly executionMode: {
+                        readonly enum: readonly ["series", "parallel"];
+                    };
+                    readonly databaseAccessDefinitions: {
+                        readonly optional: true;
+                        readonly oneOfType: readonly [{
+                            readonly mode: {
+                                readonly enum: readonly ["execute_readonly_sql"];
+                            };
+                        }, {
+                            readonly mode: {
+                                readonly enum: readonly ["execute_sql"];
+                            };
+                            readonly allowedCommands: {
+                                readonly optional: true;
+                                readonly record: {
+                                    readonly partial: true;
+                                    readonly keysEnum: readonly ["select", "insert", "update", "delete"];
+                                    readonly values: {
+                                        readonly enum: readonly [1];
+                                    };
+                                };
+                            };
+                        }, {
+                            readonly mode: {
+                                readonly enum: readonly ["custom"];
+                            };
+                            readonly tablePermissions: {
+                                readonly title: "Tables";
+                                readonly description: "Tables the assistant can access";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly type: {
+                                            readonly select: {
+                                                readonly oneOf: readonly [{
+                                                    readonly enum: readonly [true];
+                                                }, {
+                                                    readonly type: {
+                                                        readonly forcedFilter: {
+                                                            readonly optional: true;
+                                                            readonly oneOfType: readonly [{
+                                                                readonly $and: "any[]";
+                                                            }, {
+                                                                readonly $or: "any[]";
+                                                            }];
+                                                        };
+                                                        readonly fields: {
+                                                            readonly oneOf: readonly [{
+                                                                readonly enum: readonly ["*"];
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [1];
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [0];
+                                                                    };
+                                                                };
+                                                            }];
+                                                        };
+                                                    };
+                                                }];
+                                                readonly optional: true;
+                                            };
+                                            readonly update: {
+                                                readonly oneOf: readonly [{
+                                                    readonly enum: readonly [true];
+                                                }, {
+                                                    readonly type: {
+                                                        readonly forcedFilter: {
+                                                            readonly optional: true;
+                                                            readonly oneOfType: readonly [{
+                                                                readonly $and: "any[]";
+                                                            }, {
+                                                                readonly $or: "any[]";
+                                                            }];
+                                                        };
+                                                        readonly fields: {
+                                                            readonly oneOf: readonly [{
+                                                                readonly enum: readonly ["*"];
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [1];
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [0];
+                                                                    };
+                                                                };
+                                                            }];
+                                                        };
+                                                    };
+                                                }];
+                                                readonly optional: true;
+                                            };
+                                            readonly insert: {
+                                                readonly oneOf: readonly [{
+                                                    readonly enum: readonly [true];
+                                                }, {
+                                                    readonly type: {
+                                                        readonly fields: {
+                                                            readonly oneOf: readonly [{
+                                                                readonly enum: readonly ["*"];
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [1];
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly record: {
+                                                                    readonly values: {
+                                                                        readonly enum: readonly [0];
+                                                                    };
+                                                                };
+                                                            }];
+                                                        };
+                                                    };
+                                                }];
+                                                readonly optional: true;
+                                            };
+                                            readonly delete: {
+                                                readonly oneOf: readonly [{
+                                                    readonly enum: readonly [true];
+                                                }, {
+                                                    readonly type: {
+                                                        readonly forcedFilter: {
+                                                            readonly optional: true;
+                                                            readonly oneOfType: readonly [{
+                                                                readonly $and: "any[]";
+                                                            }, {
+                                                                readonly $or: "any[]";
+                                                            }];
+                                                        };
+                                                    };
+                                                }];
+                                                readonly optional: true;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            readonly ddlStatements: {
+                                readonly description: "Table create statements";
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                        }];
+                    };
+                    readonly orchestrationTools: {
+                        readonly optional: true;
+                        readonly oneOf: readonly [{
+                            readonly enum: readonly [undefined];
+                        }, {
+                            readonly record: {
+                                readonly partial: true;
+                                readonly values: {
+                                    readonly record: {
+                                        readonly partial: true;
+                                        readonly values: {
+                                            readonly enum: readonly [1];
+                                        };
+                                    };
+                                };
+                            };
+                        }];
+                    };
+                    readonly agentDefinitions: {
+                        optional: boolean;
+                        record: {
+                            values: {
+                                type: {
+                                    readonly prompt: {
+                                        readonly type: "string";
+                                    };
+                                    readonly modelName: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                        readonly description: "The name of the LLM model to use for this agent. If not provided, the default model will be used.";
+                                    };
+                                    readonly maxCostUSD: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                        readonly description: "The maximum cost in USD that this agent is allowed to incur.";
+                                    };
+                                    readonly maxIterations: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                        readonly description: "The maximum number of iterations this agent is allowed to run.";
+                                    };
+                                    readonly tools: {
+                                        readonly optional: true;
+                                        readonly record: {
+                                            readonly partial: true;
+                                            readonly values: {
+                                                readonly record: {
+                                                    readonly partial: true;
+                                                    readonly values: {
+                                                        readonly enum: readonly [1];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                    readonly mcpServerConfigs: {
+                                        readonly optional: true;
+                                        readonly description: "SYSTEM ONLY — DO NOT SPECIFY: Do not generate, invent, or prompt the user for configuration IDs. This field is automatically injected by the host runtime when a tool requires user-provided MCP server authorization.";
+                                        readonly record: {
+                                            readonly partial: true;
+                                            readonly values: {
+                                                readonly type: {
+                                                    readonly configId: {
+                                                        readonly type: "number";
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                    readonly maxTokens: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                    };
+                                    readonly temperature: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                    };
+                                    readonly outputSchema: {
+                                        readonly record: {
+                                            readonly values: {
+                                                readonly oneOf: readonly [{
+                                                    readonly type: {
+                                                        readonly optional: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly nullable: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly type: {
+                                                            readonly enum: readonly ["string", "number", "boolean", "unknown", ...("string[]" | "number[]" | "boolean[]" | "unknown[]")[]];
+                                                        };
+                                                    };
+                                                }, {
+                                                    readonly type: {
+                                                        readonly optional: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly nullable: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly type: {
+                                                            readonly record: {
+                                                                readonly values: {
+                                                                    readonly type: {
+                                                                        readonly optional: {
+                                                                            readonly type: "boolean";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly nullable: {
+                                                                            readonly type: "boolean";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly type: {
+                                                                            readonly enum: readonly ["string", "number", "boolean", "unknown", ...("string[]" | "number[]" | "boolean[]" | "unknown[]")[]];
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                }, {
+                                                    readonly type: {
+                                                        readonly optional: {
+                                                            readonly type: "boolean";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly arrayOfType: {
+                                                            readonly record: {
+                                                                readonly values: {
+                                                                    readonly type: {
+                                                                        readonly optional: {
+                                                                            readonly type: "boolean";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly nullable: {
+                                                                            readonly type: "boolean";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly type: {
+                                                                            readonly enum: readonly ["string", "number", "boolean", "unknown", ...("string[]" | "number[]" | "boolean[]" | "unknown[]")[]];
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                }];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    readonly userInput: {
+                        readonly optional: true;
+                        readonly description: string;
+                        readonly record: {
+                            readonly values: {
+                                readonly oneOfType: readonly [{
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-column-value"];
+                                    };
+                                    readonly tableName: "string";
+                                    readonly columnName: "string";
+                                    readonly defaultValue: {
+                                        readonly type: "any";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-column-values"];
+                                    };
+                                    readonly tableName: "string";
+                                    readonly columnName: "string";
+                                    readonly defaultValue: {
+                                        readonly type: "any[]";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-filter"];
+                                    };
+                                    readonly tableName: "string";
+                                    readonly defaultValue: {
+                                        readonly record: {
+                                            readonly values: "any";
+                                        };
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-column"];
+                                    };
+                                    readonly tableName: "string";
+                                    readonly defaultValue: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-name"];
+                                    };
+                                    readonly defaultValue: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["table-and-column"];
+                                    };
+                                    readonly defaultValue: {
+                                        readonly type: {
+                                            readonly tableName: "string";
+                                            readonly columnName: "string";
+                                        };
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["enum"];
+                                    };
+                                    readonly values: "string[]";
+                                    readonly defaultValue: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["custom"];
+                                    };
+                                    readonly dataType: {
+                                        readonly enum: readonly ["string", "number", "boolean", "Date"];
+                                    };
+                                    readonly defaultValue: {
+                                        readonly type: "unknown";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["folder-path", "file-path", "file-or-folder-path"];
+                                    };
+                                    readonly accessMode: {
+                                        readonly enum: readonly ["read", "read-write"];
+                                    };
+                                }, {
+                                    readonly title: "string";
+                                    readonly optional: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly type: {
+                                        readonly enum: readonly ["folder-paths", "file-paths", "file-or-folder-paths"];
+                                    };
+                                    readonly accessMode: {
+                                        readonly enum: readonly ["read", "read-write"];
+                                    };
+                                }];
+                            };
+                        };
+                    };
+                    readonly userInputValue: {
+                        readonly record: {
+                            readonly values: {
+                                readonly type: "unknown";
+                            };
+                        };
+                    };
+                    readonly newTables: {
+                        readonly optional: true;
+                        readonly arrayOfType: {
+                            readonly name: "string";
+                            readonly schema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly columns: {
+                                readonly arrayOfType: {
+                                    readonly name: "string";
+                                    readonly dataType: "string";
+                                    readonly nullable: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly isPrimaryKey: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, "name" | "userInput" | "userInputValue" | "containerConfiguration" | "databaseAccessDefinitions" | "agentDefinitions" | "chatId" | "workflowId" | "autoApproveAllTools" | "messageId" | "newTables" | "orchestrationTools" | "workflowTs" | "executionMode">>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("prostgles-types").JSONB.GetObjectType<{
+                    readonly state: {
+                        readonly enum: readonly ["finished", "error", "build-error", "timed-out", "aborted"];
+                    };
+                    readonly name: "string";
+                    readonly command: "string";
+                    readonly log: {
+                        readonly arrayOfType: {
+                            readonly type: {
+                                readonly enum: readonly ["stdout", "stderr", "error"];
+                            };
+                            readonly text: "string";
+                        };
+                    };
+                    readonly exitCode: "number";
+                    readonly runDuration: "number";
+                    readonly buildDuration: "number";
+                }> | {
+                    state: "init-error";
+                    message: string;
+                    error: string | any[] | AnyObject | null | undefined;
+                }>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly stopAgenticWorkflow: {
+                input?: {
+                    chatId: "integer";
+                    messageId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    chatId: "integer";
+                    messageId: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    success: boolean;
+                }>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getAgenticWorkflowTypes: {
+                input?: {
+                    connectionId: "string";
+                    workflowId: {
+                        optional: true;
+                        type: "number";
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                    workflowId: {
+                        optional: true;
+                        type: "number";
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    files: {
+                        "defineAgenticWorkflow.ts": string;
+                        "defineAgenticWorkflowHandlers.ts": string;
+                    };
+                    astNodes: any;
+                    summary: string;
+                    instrumentedFile: string;
+                }>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly stopDockerContainer: {
+                input?: {
+                    chatId: "integer";
+                    toolUseId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    chatId: "integer";
+                    toolUseId: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    success: boolean;
+                }>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly installMCPServer: {
+                input?: {
+                    name: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    name: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getMCPServersStatus: {
+                input?: {
+                    serverName: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    serverName: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    ok: boolean;
+                    message?: string;
+                }>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly authenticateMcpServer: {
+                input?: {
+                    serverName: "string";
+                    origin: "string";
+                    config: {
+                        type: {
+                            readonly type: {
+                                readonly enum: readonly ["OAuth"];
+                            };
+                            readonly scopes: {
+                                readonly type: "string[]";
+                            };
+                            readonly savePngIcon: "boolean";
+                            readonly auth: {
+                                readonly oneOfType: readonly [{
+                                    readonly mode: {
+                                        readonly enum: readonly ["none", "dcr"];
+                                    };
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["cimd"];
+                                    };
+                                    readonly clientMetadataUrl: {
+                                        readonly type: "string";
+                                    };
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["bearer"];
+                                    };
+                                    readonly bearerToken: {
+                                        readonly type: "string";
+                                    };
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["authorization_code"];
+                                    };
+                                    readonly clientId: "string";
+                                    readonly clientSecret: "string";
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["client_credentials"];
+                                    };
+                                    readonly clientId: "string";
+                                    readonly clientSecret: "string";
+                                    readonly tokenEndpoint: "string";
+                                }];
+                            };
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    serverName: "string";
+                    origin: "string";
+                    config: {
+                        type: {
+                            readonly type: {
+                                readonly enum: readonly ["OAuth"];
+                            };
+                            readonly scopes: {
+                                readonly type: "string[]";
+                            };
+                            readonly savePngIcon: "boolean";
+                            readonly auth: {
+                                readonly oneOfType: readonly [{
+                                    readonly mode: {
+                                        readonly enum: readonly ["none", "dcr"];
+                                    };
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["cimd"];
+                                    };
+                                    readonly clientMetadataUrl: {
+                                        readonly type: "string";
+                                    };
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["bearer"];
+                                    };
+                                    readonly bearerToken: {
+                                        readonly type: "string";
+                                    };
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["authorization_code"];
+                                    };
+                                    readonly clientId: "string";
+                                    readonly clientSecret: "string";
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["client_credentials"];
+                                    };
+                                    readonly clientId: "string";
+                                    readonly clientSecret: "string";
+                                    readonly tokenEndpoint: "string";
+                                }];
+                            };
+                        };
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getMcpOAuthMetadata: {
+                input?: {
+                    serverName: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    serverName: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    modes: {
+                        no_auth: boolean;
+                        dcr: boolean;
+                        bearer_token: boolean;
+                        cimd: boolean;
+                    };
+                    defaultMode: string | undefined;
+                    metadata: {
+                        resource: string;
+                        authorization_servers: string[];
+                        scopes_supported: string[];
+                        bearer_methods_supported?: string[];
+                        client_id_metadata_document_supported?: boolean;
+                    };
+                    serverInfo: {
+                        issuer: string;
+                        authorization_endpoint: string;
+                        registration_endpoint?: string;
+                        token_endpoint: string;
+                        response_types_supported: string[];
+                        grant_types_supported: string[];
+                        service_documentation?: string;
+                        scopes_supported: string[];
+                    };
+                }>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly reRunMCPServerTool: {
+                input?: {
+                    chatId: "integer";
+                    serverName: "string";
+                    toolName: "string";
+                    reRunToolUseId: "string";
+                    args: {
+                        record: {};
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    chatId: "integer";
+                    serverName: "string";
+                    toolName: "string";
+                    reRunToolUseId: "string";
+                    args: {
+                        record: {};
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("../McpHub/AnthropicMcpHub/McpHub").McpToolCallResponse>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly reloadMcpServerTools: {
+                input?: {
+                    serverName: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    serverName: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<number>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getMcpHostInfo: {
+                input?: Record<string, import("prostgles-types").JSONB.FieldType> | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<Record<string, import("prostgles-types").JSONB.FieldType>>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    os: string;
+                    npmVersion: string;
+                    uvxVersion: string;
+                }>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getDocumentText: {
+                input?: {
+                    files: {
+                        arrayOf: {
+                            type: "FileLike";
+                        };
+                    };
+                    options: {
+                        readonly optional: true;
+                        readonly type: {
+                            readonly from_formats: {
+                                readonly optional: true;
+                                readonly type: "string[]";
+                                readonly allowedValues: readonly ["docx", "pptx", "html", "image", "pdf", "asciidoc", "md", "csv", "xlsx", "xml_uspto", "xml_jats", "xml_xbrl", "mets_gbs", "json_docling", "audio", "vtt", "latex"];
+                            };
+                            readonly to_formats: {
+                                readonly optional: true;
+                                readonly type: "string[]";
+                                readonly allowedValues: readonly ["md", "json", "yaml", "html", "html_split_page", "text", "doctags"];
+                            };
+                            readonly image_export_mode: {
+                                readonly optional: true;
+                                readonly enum: readonly ["placeholder", "embedded", "referenced"];
+                                readonly description: "Image export mode for the document (in case of JSON, Markdown or HTML). Allowed values: placeholder, embedded, referenced. Optional, defaults to Embedded.";
+                            };
+                            readonly page_range: {
+                                readonly tuple: readonly ["number", "number"];
+                                readonly optional: true;
+                                readonly description: "Only convert a range of pages. The page number starts at 1. For example, [1, 3] will convert only the first and third pages of the document.";
+                            };
+                            readonly do_ocr: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, the bitmap content will be processed using OCR. Boolean. Optional, defaults to true";
+                            };
+                            readonly force_ocr: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, replace existing text with OCR-generated text over content. Boolean. Optional, defaults to false.";
+                            };
+                            readonly ocr_engine: {
+                                readonly enum: readonly ["auto", "easyocr", "ocrmac", "rapidocr", "tesserocr", "tesseract"];
+                                readonly optional: true;
+                                readonly description: "The OCR engine to use. String. Allowed values: auto, easyocr, ocrmac, rapidocr, tesserocr, tesseract. Optional, defaults to easyocr.";
+                            };
+                            readonly ocr_lang: {
+                                readonly type: "string[]";
+                                readonly optional: true;
+                                readonly description: "List of languages used by the OCR engine. Note that each OCR engine has different values for the language names. String or list of strings. Optional, defaults to empty.";
+                            };
+                            readonly document_timeout: {
+                                readonly optional: true;
+                                readonly type: "number";
+                                readonly description: "The timeout for processing each document, in seconds.";
+                            };
+                            readonly pdf_backend: {
+                                readonly enum: readonly ["pypdfium2", "docling_parse", "dlparse_v1", "dlparse_v2", "dlparse_v4"];
+                                readonly optional: true;
+                                readonly description: "The PDF backend to use. String. Allowed values: pypdfium2, docling_parse, dlparse_v1, dlparse_v2, dlparse_v4. Optional, defaults to docling_parse.";
+                            };
+                            readonly table_mode: {
+                                readonly enum: readonly ["fast", "accurate"];
+                                readonly optional: true;
+                                readonly description: "Mode to use for table structure, String. Allowed values: fast, accurate. Optional, defaults to accurate.";
+                            };
+                            readonly do_table_structure: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, the table structure will be extracted. Boolean. Optional, defaults to true.";
+                            };
+                            readonly include_images: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, images will be extracted from the document. Boolean. Optional, defaults to true.";
+                            };
+                            readonly md_page_break_placeholder: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "Add this placeholder between pages in the markdown output.";
+                            };
+                            readonly images_scale: {
+                                readonly type: "number";
+                                readonly optional: true;
+                                readonly description: "Scale factor for images. Float. Optional, defaults to 2.0.";
+                            };
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    files: {
+                        arrayOf: {
+                            type: "FileLike";
+                        };
+                    };
+                    options: {
+                        readonly optional: true;
+                        readonly type: {
+                            readonly from_formats: {
+                                readonly optional: true;
+                                readonly type: "string[]";
+                                readonly allowedValues: readonly ["docx", "pptx", "html", "image", "pdf", "asciidoc", "md", "csv", "xlsx", "xml_uspto", "xml_jats", "xml_xbrl", "mets_gbs", "json_docling", "audio", "vtt", "latex"];
+                            };
+                            readonly to_formats: {
+                                readonly optional: true;
+                                readonly type: "string[]";
+                                readonly allowedValues: readonly ["md", "json", "yaml", "html", "html_split_page", "text", "doctags"];
+                            };
+                            readonly image_export_mode: {
+                                readonly optional: true;
+                                readonly enum: readonly ["placeholder", "embedded", "referenced"];
+                                readonly description: "Image export mode for the document (in case of JSON, Markdown or HTML). Allowed values: placeholder, embedded, referenced. Optional, defaults to Embedded.";
+                            };
+                            readonly page_range: {
+                                readonly tuple: readonly ["number", "number"];
+                                readonly optional: true;
+                                readonly description: "Only convert a range of pages. The page number starts at 1. For example, [1, 3] will convert only the first and third pages of the document.";
+                            };
+                            readonly do_ocr: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, the bitmap content will be processed using OCR. Boolean. Optional, defaults to true";
+                            };
+                            readonly force_ocr: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, replace existing text with OCR-generated text over content. Boolean. Optional, defaults to false.";
+                            };
+                            readonly ocr_engine: {
+                                readonly enum: readonly ["auto", "easyocr", "ocrmac", "rapidocr", "tesserocr", "tesseract"];
+                                readonly optional: true;
+                                readonly description: "The OCR engine to use. String. Allowed values: auto, easyocr, ocrmac, rapidocr, tesserocr, tesseract. Optional, defaults to easyocr.";
+                            };
+                            readonly ocr_lang: {
+                                readonly type: "string[]";
+                                readonly optional: true;
+                                readonly description: "List of languages used by the OCR engine. Note that each OCR engine has different values for the language names. String or list of strings. Optional, defaults to empty.";
+                            };
+                            readonly document_timeout: {
+                                readonly optional: true;
+                                readonly type: "number";
+                                readonly description: "The timeout for processing each document, in seconds.";
+                            };
+                            readonly pdf_backend: {
+                                readonly enum: readonly ["pypdfium2", "docling_parse", "dlparse_v1", "dlparse_v2", "dlparse_v4"];
+                                readonly optional: true;
+                                readonly description: "The PDF backend to use. String. Allowed values: pypdfium2, docling_parse, dlparse_v1, dlparse_v2, dlparse_v4. Optional, defaults to docling_parse.";
+                            };
+                            readonly table_mode: {
+                                readonly enum: readonly ["fast", "accurate"];
+                                readonly optional: true;
+                                readonly description: "Mode to use for table structure, String. Allowed values: fast, accurate. Optional, defaults to accurate.";
+                            };
+                            readonly do_table_structure: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, the table structure will be extracted. Boolean. Optional, defaults to true.";
+                            };
+                            readonly include_images: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, images will be extracted from the document. Boolean. Optional, defaults to true.";
+                            };
+                            readonly md_page_break_placeholder: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "Add this placeholder between pages in the markdown output.";
+                            };
+                            readonly images_scale: {
+                                readonly type: "number";
+                                readonly optional: true;
+                                readonly description: "Scale factor for images. Float. Optional, defaults to 2.0.";
+                            };
+                        };
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("prostgles-types").JSONB.GetObjectType<{
+                    readonly document: {
+                        readonly type: {
+                            readonly filename: {
+                                readonly oneOf: readonly ["string", {
+                                    readonly enum: readonly [null];
+                                }];
+                            };
+                            readonly md_content: {
+                                readonly oneOf: readonly ["string", {
+                                    readonly enum: readonly [null];
+                                }];
+                            };
+                            readonly json_content: "any";
+                            readonly html_content: {
+                                readonly oneOf: readonly ["string", {
+                                    readonly enum: readonly [null];
+                                }];
+                            };
+                            readonly text_content: {
+                                readonly oneOf: readonly ["string", {
+                                    readonly enum: readonly [null];
+                                }];
+                            };
+                            readonly doctags_content: {
+                                readonly oneOf: readonly ["string", {
+                                    readonly enum: readonly [null];
+                                }];
+                            };
+                        };
+                    };
+                    readonly status: {
+                        readonly enum: readonly ["pending", "started", "failure", "success", "partial_success", "skipped"];
+                    };
+                    readonly errors: "any[]";
+                }>>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly transcribeAudio: {
+                input?: {
+                    audio: {
+                        type: "FileLike";
+                        mimeTypes: {
+                            "audio/webm": 1;
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    audio: {
+                        type: "FileLike";
+                        mimeTypes: {
+                            "audio/webm": 1;
+                        };
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("prostgles-types").JSONB.GetObjectType<{
+                    readonly success: {
+                        readonly type: "boolean";
+                    };
+                    readonly transcription: {
+                        readonly type: "string";
+                        readonly description: "The transcribed text from the audio";
+                    };
+                    readonly language: {
+                        readonly type: "string";
+                        readonly description: "Detected language code (e.g., 'en', 'es', 'fr')";
+                    };
+                    readonly language_probability: {
+                        readonly type: "number";
+                        readonly description: "Confidence score for detected language (0-1)";
+                    };
+                    readonly segments: {
+                        readonly arrayOfType: {
+                            readonly start: {
+                                readonly type: "number";
+                                readonly description: "Segment start time in seconds";
+                            };
+                            readonly end: {
+                                readonly type: "number";
+                                readonly description: "Segment end time in seconds";
+                            };
+                            readonly text: {
+                                readonly type: "string";
+                                readonly description: "Transcribed text for this segment";
+                            };
+                        };
+                        readonly description: "Array of transcription segments with timestamps";
+                    };
+                }> | import("prostgles-types").JSONB.GetObjectType<{
+                    readonly error: {
+                        readonly type: "string";
+                        readonly description: "Error message describing what went wrong";
+                    };
+                }>>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getRunTypescriptInNodejsFiles: {
+                input?: {
+                    entrypointTs: "string";
+                    packageDependencies: {
+                        record: {
+                            values: "string";
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    entrypointTs: "string";
+                    packageDependencies: {
+                        record: {
+                            values: "string";
+                        };
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    "index.ts": string;
+                    Dockerfile: string;
+                    "package.json": string;
+                    "eslint.config.mjs": string;
+                    "tsconfig.json": string;
+                }>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly setFileStorage: {
+                input?: {
+                    connId: "string";
+                    tableConfig: {
+                        type: {
+                            readonly fileTable: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly storageType: {
+                                readonly oneOfType: readonly [{
+                                    readonly type: {
+                                        readonly enum: readonly ["local"];
+                                    };
+                                }, {
+                                    readonly type: {
+                                        readonly enum: readonly ["S3"];
+                                    };
+                                    readonly credential_id: {
+                                        readonly type: "number";
+                                    };
+                                }];
+                            };
+                            readonly referencedTables: {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                                readonly optional: true;
+                            };
+                            readonly delayedDelete: {
+                                readonly optional: true;
+                                readonly type: {
+                                    readonly deleteAfterNDays: {
+                                        readonly type: "number";
+                                    };
+                                    readonly checkIntervalHours: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                    };
+                                };
+                            };
+                            readonly annotationsTable: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly extractText: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        };
+                        optional: true;
+                    };
+                    opts: {
+                        optional: true;
+                        type: {
+                            keepS3Data: {
+                                type: "boolean";
+                                optional: true;
+                            };
+                            keepFileTable: {
+                                type: "boolean";
+                                optional: true;
+                            };
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connId: "string";
+                    tableConfig: {
+                        type: {
+                            readonly fileTable: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly storageType: {
+                                readonly oneOfType: readonly [{
+                                    readonly type: {
+                                        readonly enum: readonly ["local"];
+                                    };
+                                }, {
+                                    readonly type: {
+                                        readonly enum: readonly ["S3"];
+                                    };
+                                    readonly credential_id: {
+                                        readonly type: "number";
+                                    };
+                                }];
+                            };
+                            readonly referencedTables: {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                                readonly optional: true;
+                            };
+                            readonly delayedDelete: {
+                                readonly optional: true;
+                                readonly type: {
+                                    readonly deleteAfterNDays: {
+                                        readonly type: "number";
+                                    };
+                                    readonly checkIntervalHours: {
+                                        readonly type: "number";
+                                        readonly optional: true;
+                                    };
+                                };
+                            };
+                            readonly annotationsTable: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly extractText: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        };
+                        optional: true;
+                    };
+                    opts: {
+                        optional: true;
+                        type: {
+                            keepS3Data: {
+                                type: "boolean";
+                                optional: true;
+                            };
+                            keepFileTable: {
+                                type: "boolean";
+                                optional: true;
+                            };
+                        };
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getStatus: {
+                input?: {
+                    connId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connId: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("../../../common/utils").ConnectionStatus>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getSampleSchemas: {
+                input?: Record<string, import("prostgles-types").JSONB.FieldType> | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<Record<string, import("prostgles-types").JSONB.FieldType>>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("../../../common/utils").SampleSchema[]>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getCompiledTS: {
+                input?: {
+                    ts: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    ts: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly killPID: {
+                input?: {
+                    readonly connId: "string";
+                    readonly id_query_hash: "string";
+                    readonly type: {
+                        readonly enum: readonly ["cancel", "terminate"];
+                        readonly optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    readonly connId: "string";
+                    readonly id_query_hash: "string";
+                    readonly type: {
+                        readonly enum: readonly ["cancel", "terminate"];
+                        readonly optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<any[]>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly setOnMount: {
+                input?: {
+                    connId: "string";
+                    changes: {
+                        type: {
+                            on_mount_ts_disabled: {
+                                type: "boolean";
+                                optional: true;
+                            };
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connId: "string";
+                    changes: {
+                        type: {
+                            on_mount_ts_disabled: {
+                                type: "boolean";
+                                optional: true;
+                            };
+                        };
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly setTableConfig: {
+                input?: {
+                    connId: "string";
+                    changes: {
+                        type: {
+                            table_config_ts: {
+                                type: "string";
+                                optional: true;
+                            };
+                            table_config_ts_disabled: {
+                                type: "boolean";
+                                optional: true;
+                            };
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connId: "string";
+                    changes: {
+                        type: {
+                            table_config_ts: {
+                                type: "string";
+                                optional: true;
+                            };
+                            table_config_ts_disabled: {
+                                type: "boolean";
+                                optional: true;
+                            };
+                        };
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getNodeTypes: {
+                input?: {
+                    projectPath: {
+                        type: "string";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    projectPath: {
+                        type: "string";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    content: string;
+                    filePath: string;
+                }[]>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly backupConnections: {
+                input?: {
+                    connectionNames: {
+                        optional: true;
+                        type: "string[]";
+                    };
+                    allActive: {
+                        optional: true;
+                        type: "boolean";
+                    };
+                    name: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionNames: {
+                        optional: true;
+                        type: "string[]";
+                    };
+                    allActive: {
+                        optional: true;
+                        type: "boolean";
+                    };
+                    name: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly restoreConnections: {
+                input?: {
+                    backupName: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    backupName: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<number>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly pgDump: {
+                input?: {
+                    conId: "string";
+                    credId: {
+                        oneOf: ("number" | {
+                            enum: null[];
+                        })[];
+                    };
+                    opts: {
+                        type: {
+                            name: {
+                                type: "string";
+                                optional: true;
+                            };
+                            initiator: {
+                                type: "string";
+                                optional: true;
+                            };
+                            options: {
+                                readonly oneOfType: readonly [{
+                                    readonly command: {
+                                        readonly enum: readonly ["pg_dumpall"];
+                                    };
+                                    readonly clean: {
+                                        readonly type: "boolean";
+                                    };
+                                    readonly dataOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly globalsOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly rolesOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly schemaOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly ifExists: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly encoding: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly keepLogs: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly command: {
+                                        readonly enum: readonly ["pg_dump"];
+                                    };
+                                    readonly format: {
+                                        readonly enum: readonly ["p", "t", "c"];
+                                    };
+                                    readonly dataOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly clean: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly create: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly encoding: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly numberOfJobs: {
+                                        readonly type: "integer";
+                                        readonly optional: true;
+                                    };
+                                    readonly noOwner: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly compressionLevel: {
+                                        readonly type: "integer";
+                                        readonly optional: true;
+                                    };
+                                    readonly ifExists: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly keepLogs: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly excludeSchema: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly schemaOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                }];
+                            };
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    conId: "string";
+                    credId: {
+                        oneOf: ("number" | {
+                            enum: null[];
+                        })[];
+                    };
+                    opts: {
+                        type: {
+                            name: {
+                                type: "string";
+                                optional: true;
+                            };
+                            initiator: {
+                                type: "string";
+                                optional: true;
+                            };
+                            options: {
+                                readonly oneOfType: readonly [{
+                                    readonly command: {
+                                        readonly enum: readonly ["pg_dumpall"];
+                                    };
+                                    readonly clean: {
+                                        readonly type: "boolean";
+                                    };
+                                    readonly dataOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly globalsOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly rolesOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly schemaOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly ifExists: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly encoding: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly keepLogs: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly command: {
+                                        readonly enum: readonly ["pg_dump"];
+                                    };
+                                    readonly format: {
+                                        readonly enum: readonly ["p", "t", "c"];
+                                    };
+                                    readonly dataOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly clean: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly create: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly encoding: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly numberOfJobs: {
+                                        readonly type: "integer";
+                                        readonly optional: true;
+                                    };
+                                    readonly noOwner: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly compressionLevel: {
+                                        readonly type: "integer";
+                                        readonly optional: true;
+                                    };
+                                    readonly ifExists: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly keepLogs: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly excludeSchema: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly schemaOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                }];
+                            };
+                        };
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string | undefined>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly pgRestore: {
+                input?: {
+                    bkpId: "string";
+                    connId: {
+                        type: "string";
+                        optional: true;
+                    };
+                    opts: "any";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    bkpId: "string";
+                    connId: {
+                        type: "string";
+                        optional: true;
+                    };
+                    opts: "any";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly bkpDelete: {
+                input?: {
+                    bkpId: "string";
+                    force: {
+                        type: "boolean";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    bkpId: "string";
+                    force: {
+                        type: "boolean";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly streamBackupFile: {
+                input?: {
+                    data: {
+                        oneOfType: readonly [{
+                            readonly type: {
+                                readonly enum: readonly ["start"];
+                            };
+                            readonly fileName: "string";
+                            readonly connectionId: "string";
+                            readonly sizeBytes: "integer";
+                            readonly restoreOptions: {
+                                readonly type: {
+                                    readonly command: {
+                                        readonly enum: readonly ["pg_restore", "psql"];
+                                    };
+                                    readonly format: {
+                                        readonly enum: readonly ["p", "t", "c"];
+                                    };
+                                    readonly clean: {
+                                        readonly type: "boolean";
+                                    };
+                                    readonly singleTransaction: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly excludeSchema: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly newDbName: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly create: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly dataOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly noOwner: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly numberOfJobs: {
+                                        readonly type: "integer";
+                                        readonly optional: true;
+                                    };
+                                    readonly ifExists: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly keepLogs: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                };
+                            };
+                        }, {
+                            readonly type: {
+                                readonly enum: readonly ["chunk"];
+                            };
+                            readonly streamId: "string";
+                            readonly chunk: "Blob";
+                        }, {
+                            readonly type: {
+                                readonly enum: readonly ["end"];
+                            };
+                            readonly streamId: "string";
+                        }];
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    data: {
+                        oneOfType: readonly [{
+                            readonly type: {
+                                readonly enum: readonly ["start"];
+                            };
+                            readonly fileName: "string";
+                            readonly connectionId: "string";
+                            readonly sizeBytes: "integer";
+                            readonly restoreOptions: {
+                                readonly type: {
+                                    readonly command: {
+                                        readonly enum: readonly ["pg_restore", "psql"];
+                                    };
+                                    readonly format: {
+                                        readonly enum: readonly ["p", "t", "c"];
+                                    };
+                                    readonly clean: {
+                                        readonly type: "boolean";
+                                    };
+                                    readonly singleTransaction: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly excludeSchema: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly newDbName: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                    readonly create: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly dataOnly: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly noOwner: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly numberOfJobs: {
+                                        readonly type: "integer";
+                                        readonly optional: true;
+                                    };
+                                    readonly ifExists: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                    readonly keepLogs: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                    };
+                                };
+                            };
+                        }, {
+                            readonly type: {
+                                readonly enum: readonly ["chunk"];
+                            };
+                            readonly streamId: "string";
+                            readonly chunk: "Blob";
+                        }, {
+                            readonly type: {
+                                readonly enum: readonly ["end"];
+                            };
+                            readonly streamId: "string";
+                        }];
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string | undefined>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly makeDirectory: {
+                input?: {
+                    path: "string";
+                    folderName: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    path: "string";
+                    folderName: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly glob: {
+                input?: {
+                    pattern: {
+                        type: "string";
+                        optional: true;
+                    };
+                    cwd: {
+                        type: "string";
+                        optional: true;
+                    };
+                    timeout: {
+                        type: "integer";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    pattern: {
+                        type: "string";
+                        optional: true;
+                    };
+                    cwd: {
+                        type: "string";
+                        optional: true;
+                    };
+                    timeout: {
+                        type: "integer";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    pattern: string;
+                    path: string;
+                    result: {
+                        path: string;
+                        name: string;
+                        type: string;
+                        size: number | undefined;
+                        lastModified: number | undefined;
+                        created: number | undefined;
+                    }[];
+                    timedOut: boolean;
+                }>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly disablePasswordless: {
+                input?: {
+                    username: "string";
+                    password: "string";
+                    origin: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    username: "string";
+                    password: "string";
+                    origin: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getConnectionDBTypes: {
+                input?: {
+                    conId: {
+                        type: "string";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    conId: {
+                        type: "string";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly runSql: {
+                input?: {
+                    readonly connectionId: "string";
+                    readonly query: "string";
+                    readonly mode: {
+                        readonly enum: readonly ["default", "readOnly"];
+                        readonly optional: true;
+                    };
+                    readonly args: {
+                        readonly type: "any";
+                        readonly optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    readonly connectionId: "string";
+                    readonly query: "string";
+                    readonly mode: {
+                        readonly enum: readonly ["default", "readOnly"];
+                        readonly optional: true;
+                    };
+                    readonly args: {
+                        readonly type: "any";
+                        readonly optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    command: string;
+                    fields: {
+                        tsDataType: "string" | "number" | "boolean" | "any" | "Uint8Array" | "string[]" | "number[]" | "boolean[]" | "any[]";
+                        dataType: import("prostgles-types").PG_COLUMN_UDT_DATA_TYPE;
+                        udt_name: import("prostgles-types").PG_COLUMN_UDT_DATA_TYPE;
+                        tableName: string | undefined;
+                        tableSchema: string | undefined;
+                        columnName: string | undefined;
+                        name: string;
+                        oid: number;
+                        dataTypeID: number;
+                        tableID: number;
+                        columnID: number;
+                        dataTypeSize: number;
+                        dataTypeModifier: number;
+                        format: string;
+                    }[];
+                    rowCount: number;
+                    rows: unknown[];
+                    duration: number | undefined;
+                }>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly runConnectionQuery: {
+                input?: {
+                    conId: "string";
+                    query: "string";
+                    args: {
+                        type: "any";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    conId: "string";
+                    query: "string";
+                    args: {
+                        type: "any";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<AnyObject[]>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getMyIP: {
+                input?: Record<string, import("prostgles-types").JSONB.FieldType> | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<Record<string, import("prostgles-types").JSONB.FieldType>>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    ip: string | undefined;
+                    ip_address: string;
+                    ip_address_remote: string | undefined;
+                    x_real_ip: string | undefined;
+                    isAllowed: boolean | null | undefined;
+                }>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getConnectedIds: {
+                input?: Record<string, import("prostgles-types").JSONB.FieldType> | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<Record<string, import("prostgles-types").JSONB.FieldType>>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string[]>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly toggleService: {
+                input?: {
+                    serviceName: "string";
+                    enable: "boolean";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    serviceName: "string";
+                    enable: "boolean";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getDBSize: {
+                input?: {
+                    conId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    conId: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getIsSuperUser: {
+                input?: {
+                    conId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    conId: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<boolean>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getFileFolderSizeInBytes: {
+                input?: {
+                    conId: {
+                        type: "string";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    conId: {
+                        type: "string";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    size: number;
+                    storagePath: string;
+                }>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly testDBConnection: {
+                input?: {
+                    connection: {
+                        record: {
+                            values: "unknown";
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connection: {
+                        record: {
+                            values: "unknown";
+                        };
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    prostglesSchemaVersion: string | undefined;
+                    connectionInfo: import("../connectionUtils/getConnectionDetails").ConnectionDetails;
+                    canCreateDb: boolean | undefined;
+                    isSSLModeFallBack?: boolean;
+                }>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly validateConnection: {
+                input?: {
+                    connection: "any";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connection: "any";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    validatedConnection: any;
+                }>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getInstalledPsqlVersions: {
+                input?: Record<string, import("prostgles-types").JSONB.FieldType> | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<Record<string, import("prostgles-types").JSONB.FieldType>>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("../../../common/electronInitTypes").InstalledPrograms | undefined>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly createConnection: {
+                input?: {
+                    connection: {
+                        record: {
+                            values: "any";
+                        };
+                    };
+                    origin: "string";
+                    sampleSchemaName: {
+                        type: "string";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connection: {
+                        record: {
+                            values: "any";
+                        };
+                    };
+                    origin: "string";
+                    sampleSchemaName: {
+                        type: "string";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    connection: Required<{
+                        config?: null | {
+                            enabled: boolean;
+                            path: string;
+                        };
+                        created?: null | string;
+                        db_conn?: null | string;
+                        db_connection_timeout?: null | number;
+                        db_host?: string;
+                        db_name: string;
+                        db_pass?: null | string;
+                        db_port?: number;
+                        db_schema_filter?: null | Record<string, 1> | Record<string, 0>;
+                        db_ssl?: "disable" | "allow" | "prefer" | "require" | "verify-ca" | "verify-full";
+                        db_user?: string;
+                        db_watch_schema?: null | boolean;
+                        disable_realtime?: null | boolean;
+                        display_options?: null | {
+                            prettyTableAndColumnNames: boolean;
+                        };
+                        id?: string;
+                        info?: null | {
+                            canCreateDb?: boolean;
+                        };
+                        is_state_db?: null | boolean;
+                        last_updated?: number | string;
+                        name: string;
+                        on_mount_ts_disabled?: null | boolean;
+                        port?: null | number;
+                        prgl_params?: null | any;
+                        prgl_url?: null | string;
+                        ssl_certificate?: null | string;
+                        ssl_client_certificate?: null | string;
+                        ssl_client_certificate_key?: null | string;
+                        ssl_reject_unauthorized?: null | boolean;
+                        table_options?: null | Partial<Record<string, {
+                            icon?: string;
+                            label?: string;
+                            rowIconColumn?: string;
+                            columns?: Partial<Record<string, {
+                                icon?: string;
+                                renderAs?: {
+                                    type: "NONE";
+                                } | {
+                                    type: "URL";
+                                } | {
+                                    type: "Email";
+                                } | {
+                                    type: "Tel";
+                                } | {
+                                    type: "QR Code";
+                                } | {
+                                    type: "Currency";
+                                    params: {
+                                        mode: "Fixed";
+                                        metricPrefix?: boolean;
+                                        currencyCode: string;
+                                    } | {
+                                        mode: "From column";
+                                        metricPrefix?: boolean;
+                                        currencyCodeField: string;
+                                    };
+                                } | {
+                                    type: "Metric Prefix";
+                                } | {
+                                    type: "UNIX Timestamp";
+                                } | {
+                                    type: "Age";
+                                    params?: {
+                                        variant: "short" | "full";
+                                    };
+                                } | {
+                                    type: "Markdown" | "MarkdownPopup";
+                                } | {
+                                    type: "DoclingDocument";
+                                } | {
+                                    type: "HTML";
+                                    params: {
+                                        noSanitize?: boolean;
+                                        allowedHTMLTags?: ("img" | "video" | "audio" | "svg" | "path")[];
+                                    };
+                                } | {
+                                    type: "Media";
+                                    params: {
+                                        contentType?: {
+                                            mode: "Auto";
+                                        } | {
+                                            mode: "Fixed";
+                                            fixedContentType: ("image" | "video" | "audio");
+                                        } | {
+                                            mode: "From column";
+                                            contentTypeColumnName: string;
+                                        } | {
+                                            mode: "From URL Extension";
+                                        };
+                                        titleColumn?: string;
+                                    };
+                                };
+                                style?: {
+                                    type: "Conditional";
+                                    conditions: ({
+                                        operator: "contains" | "=" | ">" | ">=" | "<" | "<=" | "!=";
+                                        condition: any;
+                                        textColor?: string;
+                                        chipColor?: string;
+                                        cellColor?: string;
+                                        borderColor?: string;
+                                    } | {
+                                        operator: "in" | "not in";
+                                        condition: any[];
+                                        textColor?: string;
+                                        chipColor?: string;
+                                        cellColor?: string;
+                                        borderColor?: string;
+                                    })[];
+                                    defaultStyle?: {
+                                        textColor?: string;
+                                        chipColor?: string;
+                                        cellColor?: string;
+                                        borderColor?: string;
+                                    };
+                                } | {
+                                    type: "Scale";
+                                    textColor: string;
+                                    minColor: string;
+                                    maxColor: string;
+                                } | {
+                                    type: "Barchart";
+                                    barColor: string;
+                                    textColor: string;
+                                };
+                            }>>;
+                            card?: {
+                                avatarColumn?: string;
+                                headerColumn?: string;
+                                subHeaderColumn?: string;
+                                visibleColumns?: (string | {
+                                    column: string;
+                                    hideLabel?: boolean;
+                                })[];
+                            };
+                        }>>;
+                        type: "Standard" | "Connection URI";
+                        url_path?: null | string;
+                        user_id?: null | string;
+                        web_app_directory?: null | string;
+                        web_app_templated?: null | boolean;
+                    }>;
+                    database_config: Required<{
+                        allowed_ips?: string[] | undefined;
+                        allowed_ips_enabled?: boolean | undefined;
+                        auth_created_user_type?: null | "admin" | "public" | "default" | undefined;
+                        auth_providers?: null | {
+                            website_url: string;
+                            email?: {
+                                signupType: "withMagicLink";
+                                enabled?: boolean;
+                                smtp: {
+                                    type: "smtp";
+                                    host: string;
+                                    port: number;
+                                    secure?: boolean;
+                                    rejectUnauthorized?: boolean;
+                                    user: string;
+                                    pass: string;
+                                } | {
+                                    type: "aws-ses";
+                                    region: string;
+                                    accessKeyId: string;
+                                    secretAccessKey: string;
+                                    sendingRate?: number;
+                                };
+                                emailTemplate: {
+                                    from: string;
+                                    subject: string;
+                                    body: string;
+                                };
+                                emailConfirmationEnabled?: boolean;
+                            } | {
+                                signupType: "withPassword";
+                                enabled?: boolean;
+                                minPasswordLength?: number;
+                                smtp: {
+                                    type: "smtp";
+                                    host: string;
+                                    port: number;
+                                    secure?: boolean;
+                                    rejectUnauthorized?: boolean;
+                                    user: string;
+                                    pass: string;
+                                } | {
+                                    type: "aws-ses";
+                                    region: string;
+                                    accessKeyId: string;
+                                    secretAccessKey: string;
+                                    sendingRate?: number;
+                                };
+                                emailTemplate: {
+                                    from: string;
+                                    subject: string;
+                                    body: string;
+                                };
+                                emailConfirmationEnabled?: boolean;
+                            };
+                            google?: {
+                                enabled?: boolean;
+                                clientID: string;
+                                clientSecret: string;
+                                authOpts?: {
+                                    scope: ("profile" | "email" | "calendar" | "calendar.readonly" | "calendar.events" | "calendar.events.readonly")[];
+                                };
+                            };
+                            github?: {
+                                enabled?: boolean;
+                                clientID: string;
+                                clientSecret: string;
+                                authOpts?: {
+                                    scope: ("read:user" | "user:email")[];
+                                };
+                            };
+                            microsoft?: {
+                                enabled?: boolean;
+                                clientID: string;
+                                clientSecret: string;
+                                authOpts?: {
+                                    prompt: "login" | "none" | "consent" | "select_account" | "create";
+                                    scope: ("openid" | "profile" | "email" | "offline_access" | "User.Read" | "User.ReadBasic.All" | "User.Read.All")[];
+                                };
+                            };
+                            facebook?: {
+                                enabled?: boolean;
+                                clientID: string;
+                                clientSecret: string;
+                                authOpts?: {
+                                    scope: ("email" | "public_profile" | "user_birthday" | "user_friends" | "user_gender" | "user_hometown")[];
+                                };
+                            };
+                            customOAuth?: {
+                                enabled?: boolean;
+                                clientID: string;
+                                clientSecret: string;
+                                displayName: string;
+                                displayIconPath?: string;
+                                authorizationURL: string;
+                                tokenURL: string;
+                                authOpts?: {
+                                    scope: string[];
+                                };
+                            };
+                        } | undefined;
+                        backups_config?: null | {
+                            enabled?: boolean;
+                            cloudConfig: null | {
+                                credential_id?: null | number;
+                            };
+                            frequency: "daily" | "monthly" | "weekly" | "hourly";
+                            hour?: number;
+                            dayOfWeek?: number;
+                            dayOfMonth?: number;
+                            keepLast?: number;
+                            err?: null | string;
+                            dump_options: {
+                                command: "pg_dumpall";
+                                clean: boolean;
+                                dataOnly?: boolean;
+                                globalsOnly?: boolean;
+                                rolesOnly?: boolean;
+                                schemaOnly?: boolean;
+                                ifExists?: boolean;
+                                encoding?: string;
+                                keepLogs?: boolean;
+                            } | {
+                                command: "pg_dump";
+                                format: "p" | "t" | "c";
+                                dataOnly?: boolean;
+                                clean?: boolean;
+                                create?: boolean;
+                                encoding?: string;
+                                numberOfJobs?: number;
+                                noOwner?: boolean;
+                                compressionLevel?: number;
+                                ifExists?: boolean;
+                                keepLogs?: boolean;
+                                excludeSchema?: string;
+                                schemaOnly?: boolean;
+                            };
+                        } | undefined;
+                        config_sync?: null | {
+                            configPath: string;
+                            type: "sample-schema" | "cli";
+                            toggleableProperties: Partial<Record<"tableConfig" | "functions" | "onMount", 1>>;
+                            lastSynced: string;
+                        } | undefined;
+                        cookie_options?: null | {
+                            secure?: boolean;
+                            sameSite?: "lax" | "strict" | "none";
+                        } | undefined;
+                        cors?: null | {
+                            allowedOrigins: string[];
+                            credentialsAllowed?: boolean;
+                            methods?: ("GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD")[];
+                            allowedHeaders?: ("Content-Type" | "Authorization" | "X-Requested-With" | "Accept" | "Origin" | "Access-Control-Allow-Origin")[];
+                        } | undefined;
+                        cors_csp_devmode_enabled?: boolean | undefined;
+                        csp?: null | {
+                            fontSrc?: string[];
+                            mediaSrc?: string[];
+                            objectSrc?: string[];
+                            manifestSrc?: string[];
+                            defaultSrc?: string[];
+                            frameAncestors?: string[];
+                            scriptSrc?: string[];
+                            styleSrc?: string[];
+                            connectSrc?: string[];
+                            imgSrc?: string[];
+                            frameSrc?: string[];
+                            workerSrc?: string[];
+                            formAction?: string[];
+                            baseUri?: string[];
+                            upgradeInsecureRequests?: string[];
+                            blockAllMixedContent?: string[];
+                            requireSriFor?: ("script" | "style" | "font")[];
+                            sandbox?: ("allow-forms" | "allow-modals" | "allow-orientation-lock" | "allow-pointer-lock" | "allow-popups" | "allow-popups-to-escape-sandbox" | "allow-presentation" | "allow-same-origin" | "allow-scripts" | "allow-top-navigation")[];
+                        } | undefined;
+                        csp_add_defaults_enabled?: boolean | undefined;
+                        db_host: string;
+                        db_name: string;
+                        db_port: number;
+                        enable_logs?: boolean | undefined;
+                        file_table_config?: null | {
+                            fileTable?: string;
+                            storageType: {
+                                type: "local";
+                            } | {
+                                type: "S3";
+                                credential_id: number;
+                            };
+                            referencedTables?: Record<string, any>;
+                            delayedDelete?: {
+                                deleteAfterNDays: number;
+                                checkIntervalHours?: number;
+                            };
+                            annotationsTable?: string;
+                            extractText?: boolean;
+                        } | undefined;
+                        id?: number | undefined;
+                        login_rate_limit?: {
+                            maxAttemptsPerHour: number;
+                            groupBy: "x-real-ip" | "remote_ip" | "ip";
+                        } | undefined;
+                        login_rate_limit_enabled?: boolean | undefined;
+                        magic_link_validity_days?: number | undefined;
+                        pass_process_env_vars_to_server_side_functions?: boolean | undefined;
+                        rest_api_enabled?: null | boolean | undefined;
+                        session_max_age_days?: number | undefined;
+                        sync_users?: null | boolean | undefined;
+                        table_config?: (null | Record<string, {
+                            isLookupTable: {
+                                values: Record<string, string>;
+                            };
+                        } | {
+                            columns: Record<string, string | {
+                                hint?: string;
+                                nullable?: boolean;
+                                isText?: boolean;
+                                trimmed?: boolean;
+                                defaultValue?: any;
+                            } | {
+                                jsonbSchema: {
+                                    type: "string" | "number" | "boolean" | "Date" | "time" | "timestamp" | "string[]" | "number[]" | "boolean[]" | "Date[]" | "time[]" | "timestamp[]";
+                                    optional?: boolean;
+                                    description?: string;
+                                } | {
+                                    type: "RowLookup" | "RowLookup[]" | "ValueLookup" | "ValueLookup[]" | "TableLookup" | "TableLookup[]" | "ColumnLookup" | "ColumnLookup[]";
+                                    optional?: boolean;
+                                    description?: string;
+                                } | {
+                                    type: "object";
+                                    optional?: boolean;
+                                    description?: string;
+                                };
+                            }>;
+                        }>) | undefined;
+                        table_config_ts?: null | string | undefined;
+                        table_config_ts_disabled?: null | boolean | undefined;
+                        table_schema_positions?: (null | Partial<Record<string, {
+                            x: number;
+                            y: number;
+                        }>>) | undefined;
+                        table_schema_transform?: null | {
+                            translate: {
+                                x: number;
+                                y: number;
+                            };
+                            scale: number;
+                        } | undefined;
+                        tableConfig?: null | any;
+                        trust_proxy?: boolean | undefined;
+                    }>;
+                }>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly syncSchema: {
+                input?: {
+                    connectionId: "string";
+                    configPath: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                    configPath: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly refreshModels: {
+                input?: Record<string, import("prostgles-types").JSONB.FieldType> | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<Record<string, import("prostgles-types").JSONB.FieldType>>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly reloadSchema: {
+                input?: {
+                    conId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    conId: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly deleteConnection: {
+                input?: {
+                    id: "string";
+                    dropDatabase: "boolean";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    id: "string";
+                    dropDatabase: "boolean";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<Required<{
+                    config?: null | {
+                        enabled: boolean;
+                        path: string;
+                    } | undefined;
+                    created?: null | string | undefined;
+                    db_conn?: null | string | undefined;
+                    db_connection_timeout?: null | number | undefined;
+                    db_host?: string | undefined;
+                    db_name: string;
+                    db_pass?: null | string | undefined;
+                    db_port?: number | undefined;
+                    db_schema_filter?: (null | Record<string, 1> | Record<string, 0>) | undefined;
+                    db_ssl?: "disable" | "allow" | "prefer" | "require" | "verify-ca" | "verify-full" | undefined;
+                    db_user?: string | undefined;
+                    db_watch_schema?: null | boolean | undefined;
+                    disable_realtime?: null | boolean | undefined;
+                    display_options?: null | {
+                        prettyTableAndColumnNames: boolean;
+                    } | undefined;
+                    id?: string | undefined;
+                    info?: null | {
+                        canCreateDb?: boolean;
+                    } | undefined;
+                    is_state_db?: null | boolean | undefined;
+                    last_updated?: string | undefined;
+                    name: string;
+                    on_mount_ts_disabled?: null | boolean | undefined;
+                    port?: null | number | undefined;
+                    prgl_params?: null | any;
+                    prgl_url?: null | string | undefined;
+                    ssl_certificate?: null | string | undefined;
+                    ssl_client_certificate?: null | string | undefined;
+                    ssl_client_certificate_key?: null | string | undefined;
+                    ssl_reject_unauthorized?: null | boolean | undefined;
+                    table_options?: (null | Partial<Record<string, {
+                        icon?: string;
+                        label?: string;
+                        rowIconColumn?: string;
+                        columns?: Partial<Record<string, {
+                            icon?: string;
+                            renderAs?: {
+                                type: "NONE";
+                            } | {
+                                type: "URL";
+                            } | {
+                                type: "Email";
+                            } | {
+                                type: "Tel";
+                            } | {
+                                type: "QR Code";
+                            } | {
+                                type: "Currency";
+                                params: {
+                                    mode: "Fixed";
+                                    metricPrefix?: boolean;
+                                    currencyCode: string;
+                                } | {
+                                    mode: "From column";
+                                    metricPrefix?: boolean;
+                                    currencyCodeField: string;
+                                };
+                            } | {
+                                type: "Metric Prefix";
+                            } | {
+                                type: "UNIX Timestamp";
+                            } | {
+                                type: "Age";
+                                params?: {
+                                    variant: "short" | "full";
+                                };
+                            } | {
+                                type: "Markdown" | "MarkdownPopup";
+                            } | {
+                                type: "DoclingDocument";
+                            } | {
+                                type: "HTML";
+                                params: {
+                                    noSanitize?: boolean;
+                                    allowedHTMLTags?: ("img" | "video" | "audio" | "svg" | "path")[];
+                                };
+                            } | {
+                                type: "Media";
+                                params: {
+                                    contentType?: {
+                                        mode: "Auto";
+                                    } | {
+                                        mode: "Fixed";
+                                        fixedContentType: ("image" | "video" | "audio");
+                                    } | {
+                                        mode: "From column";
+                                        contentTypeColumnName: string;
+                                    } | {
+                                        mode: "From URL Extension";
+                                    };
+                                    titleColumn?: string;
+                                };
+                            };
+                            style?: {
+                                type: "Conditional";
+                                conditions: ({
+                                    operator: "contains" | "=" | ">" | ">=" | "<" | "<=" | "!=";
+                                    condition: any;
+                                    textColor?: string;
+                                    chipColor?: string;
+                                    cellColor?: string;
+                                    borderColor?: string;
+                                } | {
+                                    operator: "in" | "not in";
+                                    condition: any[];
+                                    textColor?: string;
+                                    chipColor?: string;
+                                    cellColor?: string;
+                                    borderColor?: string;
+                                })[];
+                                defaultStyle?: {
+                                    textColor?: string;
+                                    chipColor?: string;
+                                    cellColor?: string;
+                                    borderColor?: string;
+                                };
+                            } | {
+                                type: "Scale";
+                                textColor: string;
+                                minColor: string;
+                                maxColor: string;
+                            } | {
+                                type: "Barchart";
+                                barColor: string;
+                                textColor: string;
+                            };
+                        }>>;
+                        card?: {
+                            avatarColumn?: string;
+                            headerColumn?: string;
+                            subHeaderColumn?: string;
+                            visibleColumns?: (string | {
+                                column: string;
+                                hideLabel?: boolean;
+                            })[];
+                        };
+                    }>>) | undefined;
+                    type: "Standard" | "Connection URI";
+                    url_path?: null | string | undefined;
+                    user_id?: null | string | undefined;
+                    web_app_directory?: null | string | undefined;
+                    web_app_templated?: null | boolean | undefined;
+                }>[]>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly disconnect: {
+                input?: {
+                    conId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    conId: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<boolean>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly createWebAppFromTemplate: {
+                input?: {
+                    connectionId: "string";
+                    clean: {
+                        type: "boolean";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                    clean: {
+                        type: "boolean";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly buildWebApp: {
+                input?: {
+                    connectionId: "string";
+                    clean: {
+                        type: "boolean";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                    clean: {
+                        type: "boolean";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("../McpHub/DockerSandbox/executeDockerCommand").ExecutionResult>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly testWebApp: {
+                input?: {
+                    connectionId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("../McpHub/DockerSandbox/executeDockerCommand").ExecutionResult>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly writeWebAppFiles: {
+                input?: {
+                    connectionId: "string";
+                    bypassAllowList: {
+                        type: "boolean";
+                        optional: true;
+                    };
+                    files: {
+                        record: {
+                            values: "string";
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                    bypassAllowList: {
+                        type: "boolean";
+                        optional: true;
+                    };
+                    files: {
+                        record: {
+                            values: "string";
+                        };
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<boolean>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getWebAppComponents: {
+                input?: {
+                    connectionId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    components: {
+                        filePath: string;
+                        name: string;
+                        propsTypeString: string | undefined;
+                    }[];
+                    renderTree: {
+                        componentName: string;
+                        outputTree: {
+                            name: string;
+                            children: any[];
+                            condition?: string;
+                            outputTree?: any[];
+                        }[];
+                    }[];
+                }>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getWebAppFileList: {
+                input?: {
+                    connectionId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string[]>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly readFile: {
+                input?: {
+                    filePath: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    filePath: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly saveFile: {
+                input?: {
+                    filePath: "string";
+                    content: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    filePath: "string";
+                    content: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<boolean>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getWebAppFile: {
+                input?: {
+                    connectionId: "string";
+                    relativePath: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                    relativePath: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly saveWebAppFile: {
+                input?: {
+                    connectionId: "string";
+                    fileName: "string";
+                    content: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                    fileName: "string";
+                    content: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<boolean>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+        };
+    };
+    normalUser: {
+        readonly userFilter: {};
+        readonly functions: {
+            readonly approveToolUse: {
+                input?: {
+                    id: "integer";
+                    response: {
+                        enum: readonly ["approve", "deny", "auto-approve"];
+                    };
+                    schema: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    id: "integer";
+                    response: {
+                        enum: readonly ["approve", "deny", "auto-approve"];
+                    };
+                    schema: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly askLLM: {
+                input?: {
+                    connectionId: "string";
+                    schema: "string";
+                    chatId: "integer";
+                    type: {
+                        enum: readonly ["new-message", "tool-use-result", "tool-use-result-confirmation"];
+                    };
+                    userMessage: {
+                        arrayOf: {
+                            oneOfType: [{
+                                readonly type: {
+                                    readonly enum: readonly ["text"];
+                                };
+                                readonly text: "string";
+                                readonly reasoning: {
+                                    readonly type: "string";
+                                    readonly optional: true;
+                                    readonly description: "Internal reasoning message used by the model to explain its thought process";
+                                };
+                            }, {
+                                readonly type: {
+                                    readonly enum: readonly ["text-document"];
+                                };
+                                readonly fileName: "string";
+                                readonly mimeType: {
+                                    readonly enum: readonly ["text/markdown", "text/plain"];
+                                };
+                                readonly text: "string";
+                            }, {
+                                readonly type: {
+                                    readonly enum: readonly ["image", "audio", "video", "application", "text"];
+                                };
+                                readonly source: {
+                                    readonly type: {
+                                        readonly type: {
+                                            readonly enum: readonly ["base64"];
+                                        };
+                                        readonly media_type: "string";
+                                        readonly data: "string";
+                                    };
+                                };
+                            }, {
+                                readonly type: {
+                                    readonly enum: readonly ["tool_use"];
+                                };
+                                readonly id: "string";
+                                readonly name: "string";
+                                readonly input: {
+                                    readonly record: {
+                                        readonly values: "unknown";
+                                    };
+                                    readonly optional: true;
+                                };
+                            }, {
+                                readonly type: {
+                                    readonly enum: readonly ["tool_result"];
+                                };
+                                readonly tool_use_id: "string";
+                                readonly tool_name: {
+                                    readonly type: "string";
+                                };
+                                readonly content: import("prostgles-types").JSONB.BaseOptions & {
+                                    type?: undefined;
+                                    arrayOf?: undefined;
+                                    arrayOfType?: undefined;
+                                    allowedValues?: undefined;
+                                    mimeTypes?: undefined;
+                                    enum?: undefined;
+                                    tuple?: undefined;
+                                    record?: undefined;
+                                    lookup?: undefined;
+                                } & {
+                                    oneOf: readonly import("prostgles-types").JSONB.FieldType[];
+                                    oneOfType?: undefined;
+                                };
+                                readonly is_error: {
+                                    readonly optional: true;
+                                    readonly type: "boolean";
+                                };
+                            }];
+                        };
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    connectionId: "string";
+                    schema: "string";
+                    chatId: "integer";
+                    type: {
+                        enum: readonly ["new-message", "tool-use-result", "tool-use-result-confirmation"];
+                    };
+                    userMessage: {
+                        arrayOf: {
+                            oneOfType: [{
+                                readonly type: {
+                                    readonly enum: readonly ["text"];
+                                };
+                                readonly text: "string";
+                                readonly reasoning: {
+                                    readonly type: "string";
+                                    readonly optional: true;
+                                    readonly description: "Internal reasoning message used by the model to explain its thought process";
+                                };
+                            }, {
+                                readonly type: {
+                                    readonly enum: readonly ["text-document"];
+                                };
+                                readonly fileName: "string";
+                                readonly mimeType: {
+                                    readonly enum: readonly ["text/markdown", "text/plain"];
+                                };
+                                readonly text: "string";
+                            }, {
+                                readonly type: {
+                                    readonly enum: readonly ["image", "audio", "video", "application", "text"];
+                                };
+                                readonly source: {
+                                    readonly type: {
+                                        readonly type: {
+                                            readonly enum: readonly ["base64"];
+                                        };
+                                        readonly media_type: "string";
+                                        readonly data: "string";
+                                    };
+                                };
+                            }, {
+                                readonly type: {
+                                    readonly enum: readonly ["tool_use"];
+                                };
+                                readonly id: "string";
+                                readonly name: "string";
+                                readonly input: {
+                                    readonly record: {
+                                        readonly values: "unknown";
+                                    };
+                                    readonly optional: true;
+                                };
+                            }, {
+                                readonly type: {
+                                    readonly enum: readonly ["tool_result"];
+                                };
+                                readonly tool_use_id: "string";
+                                readonly tool_name: {
+                                    readonly type: "string";
+                                };
+                                readonly content: import("prostgles-types").JSONB.BaseOptions & {
+                                    type?: undefined;
+                                    arrayOf?: undefined;
+                                    arrayOfType?: undefined;
+                                    allowedValues?: undefined;
+                                    mimeTypes?: undefined;
+                                    enum?: undefined;
+                                    tuple?: undefined;
+                                    record?: undefined;
+                                    lookup?: undefined;
+                                } & {
+                                    oneOf: readonly import("prostgles-types").JSONB.FieldType[];
+                                    oneOfType?: undefined;
+                                };
+                                readonly is_error: {
+                                    readonly optional: true;
+                                    readonly type: "boolean";
+                                };
+                            }];
+                        };
+                    };
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getFullPrompt: {
+                input?: {
+                    prompt: "string";
+                    schema: "string";
+                    connectionId: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    prompt: "string";
+                    schema: "string";
+                    connectionId: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly stopAskLLM: {
+                input?: {
+                    chatId: "integer";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    chatId: "integer";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly sendFeedback: {
+                input?: {
+                    details: "string";
+                    email: {
+                        type: "string";
+                        optional: true;
+                    };
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    details: "string";
+                    email: {
+                        type: "string";
+                        optional: true;
+                    };
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly prostglesSignup: {
+                input?: {
+                    email: "string";
+                    code: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    email: "string";
+                    code: "string";
+                }>, context: import("prostgles-server").RestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    error: unknown;
+                    hasError: boolean;
+                    token?: undefined;
+                    host?: undefined;
+                } | {
+                    token: string;
+                    host: string;
+                    readonly error?: undefined;
+                    hasError?: undefined;
+                }>;
+            } & {
+                unrestrictedDbAccess?: undefined;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly generateToken: {
+                input?: {
+                    days: "integer";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    days: "integer";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly create2FA: {
+                input?: Record<string, import("prostgles-types").JSONB.FieldType> | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<Record<string, import("prostgles-types").JSONB.FieldType>>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<{
+                    url: string;
+                    secret: string;
+                    recoveryCode: string;
+                }>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly enable2FA: {
+                input?: {
+                    token: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    token: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly disable2FA: {
+                input?: Record<string, import("prostgles-types").JSONB.FieldType> | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<Record<string, import("prostgles-types").JSONB.FieldType>>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void[] | undefined>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly changePassword: {
+                input?: {
+                    oldPassword: "string";
+                    newPassword: "string";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    oldPassword: "string";
+                    newPassword: "string";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+            readonly getLLMAllowedChatTools: {
+                input?: {
+                    chatId: "integer";
+                } | undefined;
+                description?: string;
+                run: (args: import("prostgles-types").JSONB.GetObjectType<{
+                    chatId: "integer";
+                }>, context: import("prostgles-server").UnrestrictedFunctionContext<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<import("../../../common/mcpUtils").AllowedChatTool[] | undefined>;
+            } & {
+                unrestrictedDbAccess: true;
+            } & import("prostgles-server").ServerFunctionContextMarker<DBGeneratedSchema, import("../authConfig/sessionUtils").SUser>;
+        };
+    };
+};
+export declare const runConnectionQuery: <T extends AnyObject = AnyObject>(connId: string, query: string, args?: AnyObject | any[], asAdminOpts?: {
+    dbs: DBS;
+}, 
+/**
+ * The database might have been deleted. Try and find one that is available
+ */
+findFirstAvailableInServer?: boolean) => Promise<T[]>;
+//# sourceMappingURL=stateServerFunctions.d.ts.map