@hotmeshio/long-tail 0.1.14 → 0.1.16

package/build/api/escalations/single.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEscalation = getEscalation;
+exports.getEscalationsByWorkflowId = getEscalationsByWorkflowId;
+exports.escalateToRole = escalateToRole;
+const escalationService = __importStar(require("../../services/escalation"));
+const userService = __importStar(require("../../services/user"));
+const roleService = __importStar(require("../../services/role"));
+// ── Single-escalation routes ───────────────────────────────────────────────
+/**
+ * Get a single escalation by ID.
+ *
+ * Non-superadmin users must hold the escalation's assigned role.
+ *
+ * @param input.id — escalation UUID
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: <escalation record> }` or 403/404
+ */
+async function getEscalation(input, auth) {
+    try {
+        const escalation = await escalationService.getEscalation(input.id);
+        if (!escalation) {
+            return { status: 404, error: 'Escalation not found' };
+        }
+        const isSuperAdminUser = await userService.isSuperAdmin(auth.userId);
+        if (!isSuperAdminUser) {
+            const userHasRole = await userService.hasRole(auth.userId, escalation.role);
+            if (!userHasRole) {
+                return { status: 403, error: 'Not authorized to view this escalation' };
+            }
+        }
+        return { status: 200, data: escalation };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * List all escalations for a given workflow ID.
+ *
+ * @param input.workflowId — HotMesh workflow ID
+ * @returns `{ status: 200, data: { escalations } }`
+ */
+async function getEscalationsByWorkflowId(input) {
+    try {
+        const escalations = await escalationService.getEscalationsByWorkflowId(input.workflowId);
+        return { status: 200, data: { escalations } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Route a pending escalation to a different role.
+ *
+ * The user must be authorized to escalate from the current role to the
+ * target role (checked via escalation chain configuration).
+ *
+ * @param input.id — escalation UUID
+ * @param input.targetRole — destination role
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: <updated escalation> }` or 403/404/409
+ */
+async function escalateToRole(input, auth) {
+    try {
+        const { id, targetRole } = input;
+        if (!targetRole || typeof targetRole !== 'string') {
+            return { status: 400, error: 'targetRole is required' };
+        }
+        const escalation = await escalationService.getEscalation(id);
+        if (!escalation) {
+            return { status: 404, error: 'Escalation not found' };
+        }
+        if (escalation.status !== 'pending') {
+            return { status: 409, error: 'Escalation is not pending' };
+        }
+        const canEscalate = await roleService.canEscalateTo(auth.userId, escalation.role, targetRole);
+        if (!canEscalate) {
+            return { status: 403, error: 'Not authorized to escalate to this role' };
+        }
+        const updated = await escalationService.escalateToRole(id, targetRole);
+        if (!updated) {
+            return { status: 409, error: 'Escalation could not be updated' };
+        }
+        return { status: 200, data: updated };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/files.d.ts

@@ -7,6 +7,9 @@ export declare function browseFiles(input: {
 export declare function getFileMetadata(input: {
     filePath: string;
 }): Promise<LTApiResult>;
+export declare function deleteFile(input: {
+    filePath: string;
+}): Promise<LTApiResult>;
 export declare function generateSignedUrl(input: {
     filePath: string;
     expiresIn: number;

package/build/api/files.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.browseFiles = browseFiles;
 exports.getFileMetadata = getFileMetadata;
+exports.deleteFile = deleteFile;
 exports.generateSignedUrl = generateSignedUrl;
 const storage_1 = require("../lib/storage");
+const mime_1 = require("../lib/storage/mime");
 const ALLOWED_EXPIRY = [3600, 21600, 86400, 604800, 2592000]; // 1h, 6h, 24h, 7d, 30d
 async function browseFiles(input) {
     try {
@@ -17,7 +19,10 @@ async function browseFiles(input) {
 async function getFileMetadata(input) {
     try {
         const metadata = await (0, storage_1.getStorageBackend)().getMetadata(input.filePath);
-        return { status: 200, data: { path: input.filePath, ...metadata } };
+        const contentType = (!metadata.content_type || metadata.content_type === 'application/octet-stream')
+            ? (0, mime_1.mimeFromPath)(input.filePath)
+            : metadata.content_type;
+        return { status: 200, data: { path: input.filePath, ...metadata, content_type: contentType } };
     }
     catch (err) {
         if (err.message?.includes('not found') || err.name === 'NotFound') {
@@ -26,6 +31,18 @@ async function getFileMetadata(input) {
         return { status: 500, error: err.message };
     }
 }
+async function deleteFile(input) {
+    try {
+        const result = await (0, storage_1.getStorageBackend)().delete(input.filePath);
+        if (!result.deleted) {
+            return { status: 404, error: 'File not found' };
+        }
+        return { status: 200, data: { deleted: true, path: input.filePath } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
 async function generateSignedUrl(input) {
     if (!ALLOWED_EXPIRY.includes(input.expiresIn)) {
         return {

package/build/api/knowledge.d.ts

@@ -0,0 +1,36 @@
+import type { LTApiResult } from '../types/sdk';
+export declare function listDomains(): Promise<LTApiResult>;
+export declare function listEntries(input: {
+    domain: string;
+    tags?: string[];
+    search?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<LTApiResult>;
+export declare function getEntry(input: {
+    domain: string;
+    key: string;
+}): Promise<LTApiResult>;
+export declare function storeEntry(input: {
+    domain: string;
+    key: string;
+    data: Record<string, any>;
+    tags?: string[];
+    replace?: boolean;
+}): Promise<LTApiResult>;
+export declare function setField(input: {
+    domain: string;
+    key: string;
+    path: string;
+    value: any;
+    tags?: string[];
+}): Promise<LTApiResult>;
+export declare function removeField(input: {
+    domain: string;
+    key: string;
+    path: string;
+}): Promise<LTApiResult>;
+export declare function deleteEntry(input: {
+    domain: string;
+    key: string;
+}): Promise<LTApiResult>;

package/build/api/knowledge.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listDomains = listDomains;
+exports.listEntries = listEntries;
+exports.getEntry = getEntry;
+exports.storeEntry = storeEntry;
+exports.setField = setField;
+exports.removeField = removeField;
+exports.deleteEntry = deleteEntry;
+const knowledgeActivity = __importStar(require("../system/activities/knowledge"));
+async function listDomains() {
+    try {
+        const result = await knowledgeActivity.listDomains();
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function listEntries(input) {
+    try {
+        const result = await knowledgeActivity.listKnowledge(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getEntry(input) {
+    try {
+        const result = await knowledgeActivity.getKnowledge(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function storeEntry(input) {
+    try {
+        const result = await knowledgeActivity.storeKnowledge(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function setField(input) {
+    try {
+        const result = await knowledgeActivity.setKnowledgeField(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function removeField(input) {
+    try {
+        const result = await knowledgeActivity.removeKnowledgeField(input);
+        if (!result.removed) {
+            return { status: 404, error: 'Field not found' };
+        }
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function deleteEntry(input) {
+    try {
+        const result = await knowledgeActivity.deleteKnowledge(input);
+        if (!result.deleted) {
+            return { status: 404, error: 'Entry not found' };
+        }
+        return { status: 200, data: { deleted: true, domain: input.domain, key: input.key } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/mcp/index.d.ts

@@ -0,0 +1,2 @@
+export { listMcpServers, createMcpServer, testConnection, getMcpServer, updateMcpServer, deleteMcpServer, connectMcpServer, disconnectMcpServer, getCredentialStatus, } from './servers';
+export { listMcpServerTools, callMcpTool, } from './tools';

package/build/api/mcp/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callMcpTool = exports.listMcpServerTools = exports.getCredentialStatus = exports.disconnectMcpServer = exports.connectMcpServer = exports.deleteMcpServer = exports.updateMcpServer = exports.getMcpServer = exports.testConnection = exports.createMcpServer = exports.listMcpServers = void 0;
+var servers_1 = require("./servers");
+Object.defineProperty(exports, "listMcpServers", { enumerable: true, get: function () { return servers_1.listMcpServers; } });
+Object.defineProperty(exports, "createMcpServer", { enumerable: true, get: function () { return servers_1.createMcpServer; } });
+Object.defineProperty(exports, "testConnection", { enumerable: true, get: function () { return servers_1.testConnection; } });
+Object.defineProperty(exports, "getMcpServer", { enumerable: true, get: function () { return servers_1.getMcpServer; } });
+Object.defineProperty(exports, "updateMcpServer", { enumerable: true, get: function () { return servers_1.updateMcpServer; } });
+Object.defineProperty(exports, "deleteMcpServer", { enumerable: true, get: function () { return servers_1.deleteMcpServer; } });
+Object.defineProperty(exports, "connectMcpServer", { enumerable: true, get: function () { return servers_1.connectMcpServer; } });
+Object.defineProperty(exports, "disconnectMcpServer", { enumerable: true, get: function () { return servers_1.disconnectMcpServer; } });
+Object.defineProperty(exports, "getCredentialStatus", { enumerable: true, get: function () { return servers_1.getCredentialStatus; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "listMcpServerTools", { enumerable: true, get: function () { return tools_1.listMcpServerTools; } });
+Object.defineProperty(exports, "callMcpTool", { enumerable: true, get: function () { return tools_1.callMcpTool; } });

package/build/api/{mcp.d.ts → mcp/servers.d.ts}

@@ -1,4 +1,4 @@
-import type { LTApiResult, LTApiAuth } from '../types/sdk';
+import type { LTApiResult, LTApiAuth } from '../../types/sdk';
 /**
  * List registered MCP servers with optional filtering and pagination.
  *
@@ -126,35 +126,3 @@ export declare function disconnectMcpServer(input: {
 export declare function getCredentialStatus(input: {
     id: string;
 }, auth?: LTApiAuth): Promise<LTApiResult>;
-/**
- * List all tools exposed by a connected MCP server.
- *
- * Requires the MCP adapter to be registered and the server to be connected.
- *
- * @param input.id — the MCP server identifier
- * @returns `{ status: 200, data: { tools } }` array of tool descriptors
- */
-export declare function listMcpServerTools(input: {
-    id: string;
-}): Promise<LTApiResult>;
-/**
- * Invoke a specific tool on a connected MCP server.
- *
- * Passes the tool arguments and an optional auth context (derived from
- * `execute_as` or the authenticated user) to the MCP adapter. Returns
- * 422 with `missing_credential` if the tool requires a credential the
- * user has not registered.
- *
- * @param input.id — the MCP server identifier
- * @param input.toolName — name of the tool to invoke
- * @param input.arguments — key-value arguments to pass to the tool
- * @param input.execute_as — optional user ID to impersonate for the tool call
- * @param auth — authenticated user context
- * @returns `{ status: 200, data: { result } }` the tool execution result
- */
-export declare function callMcpTool(input: {
-    id: string;
-    toolName: string;
-    arguments?: Record<string, any>;
-    execute_as?: string;
-}, auth?: LTApiAuth): Promise<LTApiResult>;

package/build/api/{mcp.js → mcp/servers.js}

@@ -42,10 +42,8 @@ exports.deleteMcpServer = deleteMcpServer;
 exports.connectMcpServer = connectMcpServer;
 exports.disconnectMcpServer = disconnectMcpServer;
 exports.getCredentialStatus = getCredentialStatus;
-exports.listMcpServerTools = listMcpServerTools;
-exports.callMcpTool = callMcpTool;
-const mcpDbService = __importStar(require("../services/mcp/db"));
-const mcp_1 = require("../services/mcp");
+const mcpDbService = __importStar(require("../../services/mcp/db"));
+const mcp_1 = require("../../services/mcp");
 /**
  * List registered MCP servers with optional filtering and pagination.
  *
@@ -113,7 +111,7 @@ async function testConnection(input) {
         if (!input.transport_type || !input.transport_config) {
             return { status: 400, error: 'transport_type and transport_config are required' };
         }
-        const { testConnection: testConn } = await Promise.resolve().then(() => __importStar(require('../services/mcp/client/connection')));
+        const { testConnection: testConn } = await Promise.resolve().then(() => __importStar(require('../../services/mcp/client/connection')));
         const result = await testConn(input.transport_type, input.transport_config);
         return { status: 200, data: result };
     }
@@ -241,7 +239,7 @@ async function getCredentialStatus(input, auth) {
         const registered = [];
         const missing = [];
         if (auth?.userId && required.length > 0) {
-            const { resolveCredential } = await Promise.resolve().then(() => __importStar(require('../services/iam/credentials')));
+            const { resolveCredential } = await Promise.resolve().then(() => __importStar(require('../../services/iam/credentials')));
             for (const provider of required) {
                 const cred = await resolveCredential({ id: auth.userId, type: 'user', roles: [] }, provider);
                 if (cred)
@@ -259,62 +257,3 @@ async function getCredentialStatus(input, auth) {
         return { status: 500, error: err.message };
     }
 }
-/**
- * List all tools exposed by a connected MCP server.
- *
- * Requires the MCP adapter to be registered and the server to be connected.
- *
- * @param input.id — the MCP server identifier
- * @returns `{ status: 200, data: { tools } }` array of tool descriptors
- */
-async function listMcpServerTools(input) {
-    try {
-        const adapter = mcp_1.mcpRegistry.current;
-        if (!adapter) {
-            return { status: 400, error: 'MCP adapter not registered' };
-        }
-        const tools = await adapter.listTools(input.id);
-        return { status: 200, data: { tools } };
-    }
-    catch (err) {
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Invoke a specific tool on a connected MCP server.
- *
- * Passes the tool arguments and an optional auth context (derived from
- * `execute_as` or the authenticated user) to the MCP adapter. Returns
- * 422 with `missing_credential` if the tool requires a credential the
- * user has not registered.
- *
- * @param input.id — the MCP server identifier
- * @param input.toolName — name of the tool to invoke
- * @param input.arguments — key-value arguments to pass to the tool
- * @param input.execute_as — optional user ID to impersonate for the tool call
- * @param auth — authenticated user context
- * @returns `{ status: 200, data: { result } }` the tool execution result
- */
-async function callMcpTool(input, auth) {
-    try {
-        const adapter = mcp_1.mcpRegistry.current;
-        if (!adapter) {
-            return { status: 400, error: 'MCP adapter not registered' };
-        }
-        const authContext = (input.execute_as || auth?.userId)
-            ? { userId: input.execute_as || auth?.userId }
-            : undefined;
-        const result = await adapter.callTool(input.id, input.toolName, input.arguments || {}, authContext);
-        return { status: 200, data: { result } };
-    }
-    catch (err) {
-        if (err.name === 'MissingCredentialError') {
-            return {
-                status: 422,
-                error: 'missing_credential',
-                ...{ provider: err.provider, message: err.message },
-            };
-        }
-        return { status: 500, error: err.message };
-    }
-}

package/build/api/mcp/tools.d.ts

@@ -0,0 +1,33 @@
+import type { LTApiResult, LTApiAuth } from '../../types/sdk';
+/**
+ * List all tools exposed by a connected MCP server.
+ *
+ * Requires the MCP adapter to be registered and the server to be connected.
+ *
+ * @param input.id — the MCP server identifier
+ * @returns `{ status: 200, data: { tools } }` array of tool descriptors
+ */
+export declare function listMcpServerTools(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Invoke a specific tool on a connected MCP server.
+ *
+ * Passes the tool arguments and an optional auth context (derived from
+ * `execute_as` or the authenticated user) to the MCP adapter. Returns
+ * 422 with `missing_credential` if the tool requires a credential the
+ * user has not registered.
+ *
+ * @param input.id — the MCP server identifier
+ * @param input.toolName — name of the tool to invoke
+ * @param input.arguments — key-value arguments to pass to the tool
+ * @param input.execute_as — optional user ID to impersonate for the tool call
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { result } }` the tool execution result
+ */
+export declare function callMcpTool(input: {
+    id: string;
+    toolName: string;
+    arguments?: Record<string, any>;
+    execute_as?: string;
+}, auth?: LTApiAuth): Promise<LTApiResult>;

package/build/api/mcp/tools.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listMcpServerTools = listMcpServerTools;
+exports.callMcpTool = callMcpTool;
+const mcp_1 = require("../../services/mcp");
+/**
+ * List all tools exposed by a connected MCP server.
+ *
+ * Requires the MCP adapter to be registered and the server to be connected.
+ *
+ * @param input.id — the MCP server identifier
+ * @returns `{ status: 200, data: { tools } }` array of tool descriptors
+ */
+async function listMcpServerTools(input) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        const tools = await adapter.listTools(input.id);
+        return { status: 200, data: { tools } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Invoke a specific tool on a connected MCP server.
+ *
+ * Passes the tool arguments and an optional auth context (derived from
+ * `execute_as` or the authenticated user) to the MCP adapter. Returns
+ * 422 with `missing_credential` if the tool requires a credential the
+ * user has not registered.
+ *
+ * @param input.id — the MCP server identifier
+ * @param input.toolName — name of the tool to invoke
+ * @param input.arguments — key-value arguments to pass to the tool
+ * @param input.execute_as — optional user ID to impersonate for the tool call
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { result } }` the tool execution result
+ */
+async function callMcpTool(input, auth) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        const authContext = (input.execute_as || auth?.userId)
+            ? { userId: input.execute_as || auth?.userId }
+            : undefined;
+        const result = await adapter.callTool(input.id, input.toolName, input.arguments || {}, authContext);
+        return { status: 200, data: { result } };
+    }
+    catch (err) {
+        if (err.name === 'MissingCredentialError') {
+            return {
+                status: 422,
+                error: 'missing_credential',
+                ...{ provider: err.provider, message: err.message },
+            };
+        }
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/settings.js

@@ -18,7 +18,12 @@ async function getSettings() {
     try {
         const hasSocketIO = !!events_1.eventRegistry.getAdapter(socketio_1.SocketIOEventAdapter);
         const hasNats = !!events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
-        const transport = hasSocketIO ? 'socketio' : hasNats ? 'nats' : 'none';
+        // Dashboard transport: Socket.IO is the default (works in-process, zero config).
+        // NATS is only reported when explicitly opted in via EVENT_TRANSPORT=nats,
+        // which a multi-container deployment sets when it wants the dashboard to
+        // connect via NATS instead of Socket.IO.
+        const forceNats = process.env.EVENT_TRANSPORT === 'nats';
+        const transport = forceNats && hasNats ? 'nats' : hasSocketIO ? 'socketio' : hasNats ? 'nats' : 'none';
         return {
             status: 200,
             data: {

package/build/api/workflows/config.d.ts

@@ -0,0 +1,64 @@
+import type { LTApiResult } from '../../types/sdk';
+/**
+ * List all registered workflow configurations.
+ *
+ * @returns `{ status: 200, data: { workflows: LTWorkflowConfig[] } }`
+ */
+export declare function listWorkflowConfigs(): Promise<LTApiResult>;
+/**
+ * Get a single workflow configuration by type.
+ *
+ * @param input.type — workflow type name (e.g. `"reviewContent"`)
+ * @returns `{ status: 200, data: <config> }` or 404
+ */
+export declare function getWorkflowConfig(input: {
+    type: string;
+}): Promise<LTApiResult>;
+/**
+ * Create or replace a workflow configuration.
+ *
+ * Invalidates the config cache and restarts the cron schedule if one
+ * is defined. Idempotent — safe to call repeatedly with the same input.
+ *
+ * @param input.type — workflow type name
+ * @param input.invocable — whether the workflow can be started via the API
+ * @param input.task_queue — HotMesh task queue
+ * @param input.default_role — default escalation role
+ * @param input.description — human-readable description
+ * @param input.execute_as — service account for proxy invocation
+ * @param input.roles — roles that can resolve escalations
+ * @param input.invocation_roles — roles that can invoke this workflow
+ * @param input.consumes — workflow types whose data this workflow consumes
+ * @param input.tool_tags — MCP tool tags for discovery
+ * @param input.envelope_schema — JSON Schema for envelope.data validation
+ * @param input.resolver_schema — JSON Schema for resolver payload validation
+ * @param input.cron_schedule — cron expression for scheduled execution
+ * @returns `{ status: 200, data: <saved config> }`
+ */
+export declare function upsertWorkflowConfig(input: {
+    type: string;
+    invocable?: boolean;
+    task_queue?: string | null;
+    default_role?: string;
+    description?: string | null;
+    execute_as?: string | null;
+    roles?: string[];
+    invocation_roles?: string[];
+    consumes?: string[];
+    tool_tags?: string[];
+    envelope_schema?: any;
+    resolver_schema?: any;
+    cron_schedule?: string | null;
+}): Promise<LTApiResult>;
+/**
+ * Delete a workflow configuration.
+ *
+ * Removes the config record and invalidates the cache. Active workers
+ * continue running — this only removes the config/interceptor binding.
+ *
+ * @param input.type — workflow type name
+ * @returns `{ status: 200, data: { deleted: true, workflow_type } }` or 404
+ */
+export declare function deleteWorkflowConfig(input: {
+    type: string;
+}): Promise<LTApiResult>;