@hotmeshio/long-tail 0.1.5 → 0.1.7

package/build/api/escalations.js

@@ -0,0 +1,656 @@
+"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.listEscalations = listEscalations;
+exports.listAvailableEscalations = listAvailableEscalations;
+exports.listDistinctTypes = listDistinctTypes;
+exports.getEscalationStats = getEscalationStats;
+exports.getEscalation = getEscalation;
+exports.getEscalationsByWorkflowId = getEscalationsByWorkflowId;
+exports.escalateToRole = escalateToRole;
+exports.claimEscalation = claimEscalation;
+exports.releaseEscalation = releaseEscalation;
+exports.releaseExpiredClaims = releaseExpiredClaims;
+exports.updatePriority = updatePriority;
+exports.bulkClaim = bulkClaim;
+exports.bulkAssign = bulkAssign;
+exports.bulkEscalate = bulkEscalate;
+exports.bulkTriage = bulkTriage;
+exports.resolveEscalation = resolveEscalation;
+const escalationService = __importStar(require("../services/escalation"));
+const userService = __importStar(require("../services/user"));
+const roleService = __importStar(require("../services/role"));
+const taskService = __importStar(require("../services/task"));
+const publish_1 = require("../lib/events/publish");
+const escalation_strategy_1 = require("../services/escalation-strategy");
+const ephemeral_1 = require("../services/iam/ephemeral");
+const deployer_1 = require("../services/yaml-workflow/deployer");
+const workers_1 = require("../workers");
+const defaults_1 = require("../modules/defaults");
+// ── Private helpers ────────────────────────────────────────────────────────
+async function getVisibleRoles(userId) {
+    const isSuperAdminUser = await userService.isSuperAdmin(userId);
+    if (isSuperAdminUser)
+        return undefined;
+    const userRoles = await userService.getUserRoles(userId);
+    return userRoles.map((r) => r.role);
+}
+function validateIds(ids) {
+    return Array.isArray(ids) && ids.length > 0;
+}
+async function checkBulkPermission(userId, ids) {
+    const isSuperAdminUser = await userService.isSuperAdmin(userId);
+    if (isSuperAdminUser)
+        return { allowed: true };
+    const roles = await escalationService.getEscalationRoles(ids);
+    for (const role of roles) {
+        const canManage = await userService.isGroupAdmin(userId, role);
+        if (!canManage) {
+            return { allowed: false, status: 403, error: `Insufficient permissions for role "${role}"` };
+        }
+    }
+    return { allowed: true };
+}
+function publishBulkClaimEvents(ids, assignedTo) {
+    for (const id of ids) {
+        (0, publish_1.publishEscalationEvent)({
+            type: 'escalation.claimed',
+            source: 'api',
+            workflowId: '',
+            workflowName: '',
+            taskQueue: '',
+            escalationId: id,
+            status: 'claimed',
+            data: { assigned_to: assignedTo, bulk: true },
+        });
+    }
+}
+// ── List routes ────────────────────────────────────────────────────────────
+async function listEscalations(input, auth) {
+    try {
+        const visibleRoles = await getVisibleRoles(auth.userId);
+        if (visibleRoles && visibleRoles.length === 0) {
+            return { status: 200, data: { escalations: [], total: 0 } };
+        }
+        const result = await escalationService.listEscalations({
+            status: input.status,
+            role: input.role,
+            type: input.type,
+            subtype: input.subtype,
+            assigned_to: input.assigned_to,
+            priority: input.priority,
+            limit: input.limit,
+            offset: input.offset,
+            sort_by: input.sort_by,
+            order: input.order,
+            visibleRoles,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function listAvailableEscalations(input, auth) {
+    try {
+        const visibleRoles = await getVisibleRoles(auth.userId);
+        if (visibleRoles && visibleRoles.length === 0) {
+            return { status: 200, data: { escalations: [], total: 0 } };
+        }
+        const result = await escalationService.listAvailableEscalations({
+            role: input.role,
+            type: input.type,
+            subtype: input.subtype,
+            priority: input.priority,
+            limit: input.limit,
+            offset: input.offset,
+            sort_by: input.sort_by,
+            order: input.order,
+            visibleRoles,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function listDistinctTypes() {
+    try {
+        const types = await escalationService.listDistinctTypes();
+        return { status: 200, data: { types } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getEscalationStats(input, auth) {
+    try {
+        const visibleRoles = await getVisibleRoles(auth.userId);
+        if (visibleRoles && visibleRoles.length === 0) {
+            return {
+                status: 200,
+                data: {
+                    pending: 0,
+                    claimed: 0,
+                    created: 0,
+                    resolved: 0,
+                    by_role: [],
+                    by_type: [],
+                },
+            };
+        }
+        const stats = await escalationService.getEscalationStats(visibleRoles, input.period);
+        return { status: 200, data: stats };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// ── Single-escalation routes ───────────────────────────────────────────────
+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 };
+    }
+}
+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 };
+    }
+}
+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 };
+    }
+}
+async function claimEscalation(input, auth) {
+    try {
+        const { id, durationMinutes } = input;
+        const escalation = await escalationService.getEscalation(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: `You must have the "${escalation.role}" role to claim this escalation`,
+                };
+            }
+        }
+        const result = await escalationService.claimEscalation(id, auth.userId, durationMinutes);
+        if (!result) {
+            return { status: 409, error: 'Escalation not available for claim' };
+        }
+        (0, publish_1.publishEscalationEvent)({
+            type: 'escalation.claimed',
+            source: 'api',
+            workflowId: escalation.workflow_id || '',
+            workflowName: escalation.workflow_type || '',
+            taskQueue: escalation.task_queue || '',
+            escalationId: id,
+            status: 'claimed',
+            data: { assigned_to: auth.userId },
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function releaseEscalation(input, auth) {
+    try {
+        const result = await escalationService.releaseEscalation(input.id, auth.userId);
+        if (!result) {
+            return { status: 409, error: 'Escalation not found or not claimed by you' };
+        }
+        (0, publish_1.publishEscalationEvent)({
+            type: 'escalation.released',
+            source: 'api',
+            workflowId: result.workflow_id || '',
+            workflowName: result.workflow_type || '',
+            taskQueue: result.task_queue || '',
+            escalationId: input.id,
+            status: 'released',
+            data: { released_by: auth.userId },
+        });
+        return { status: 200, data: { escalation: result } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// ── Bulk routes ────────────────────────────────────────────────────────────
+async function releaseExpiredClaims() {
+    try {
+        const released = await escalationService.releaseExpiredClaims();
+        return { status: 200, data: { released } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function updatePriority(input, auth) {
+    try {
+        const { ids, priority } = input;
+        if (!validateIds(ids)) {
+            return { status: 400, error: 'ids must be a non-empty array' };
+        }
+        if (![1, 2, 3, 4].includes(priority)) {
+            return { status: 400, error: 'priority must be 1, 2, 3, or 4' };
+        }
+        const perm = await checkBulkPermission(auth.userId, ids);
+        if (!perm.allowed)
+            return perm;
+        const updated = await escalationService.updateEscalationsPriority(ids, priority);
+        return { status: 200, data: { updated } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function bulkClaim(input, auth) {
+    try {
+        const { ids, durationMinutes } = input;
+        if (!validateIds(ids)) {
+            return { status: 400, error: 'ids must be a non-empty array' };
+        }
+        const perm = await checkBulkPermission(auth.userId, ids);
+        if (!perm.allowed)
+            return perm;
+        const result = await escalationService.bulkClaimEscalations(ids, auth.userId, durationMinutes ?? 30);
+        if (result.claimed > 0)
+            publishBulkClaimEvents(ids, auth.userId);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function bulkAssign(input, auth) {
+    try {
+        const { ids, targetUserId, durationMinutes } = input;
+        if (!validateIds(ids)) {
+            return { status: 400, error: 'ids must be a non-empty array' };
+        }
+        if (!targetUserId || typeof targetUserId !== 'string') {
+            return { status: 400, error: 'targetUserId is required' };
+        }
+        const perm = await checkBulkPermission(auth.userId, ids);
+        if (!perm.allowed)
+            return perm;
+        // Non-superadmin: target user must hold each escalation's role
+        const isSuperAdminUser = await userService.isSuperAdmin(auth.userId);
+        if (!isSuperAdminUser) {
+            const roles = await escalationService.getEscalationRoles(ids);
+            for (const role of roles) {
+                const targetHasRole = await userService.hasRole(targetUserId, role);
+                if (!targetHasRole) {
+                    return { status: 400, error: `Target user does not hold the "${role}" role` };
+                }
+            }
+        }
+        const result = await escalationService.bulkAssignEscalations(ids, targetUserId, durationMinutes ?? 30);
+        if (result.assigned > 0)
+            publishBulkClaimEvents(ids, targetUserId);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function bulkEscalate(input, auth) {
+    try {
+        const { ids, targetRole } = input;
+        if (!validateIds(ids)) {
+            return { status: 400, error: 'ids must be a non-empty array' };
+        }
+        if (!targetRole || typeof targetRole !== 'string') {
+            return { status: 400, error: 'targetRole is required' };
+        }
+        const perm = await checkBulkPermission(auth.userId, ids);
+        if (!perm.allowed)
+            return perm;
+        const updated = await escalationService.bulkEscalateToRole(ids, targetRole);
+        return { status: 200, data: { updated } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function bulkTriage(input, auth) {
+    try {
+        const { ids, hint } = input;
+        if (!validateIds(ids)) {
+            return { status: 400, error: 'ids must be a non-empty array' };
+        }
+        const perm = await checkBulkPermission(auth.userId, ids);
+        if (!perm.allowed)
+            return perm;
+        const resolved = await escalationService.bulkResolveForTriage(ids, hint);
+        const client = (0, workers_1.createClient)();
+        const workflowIds = [];
+        for (const escalation of resolved) {
+            const triageWorkflowId = await startTriageWorkflow(escalation, hint, auth.userId, client);
+            workflowIds.push(triageWorkflowId);
+        }
+        return { status: 200, data: { triaged: resolved.length, workflows: workflowIds } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// ── Resolve route ──────────────────────────────────────────────────────────
+async function resolveEscalation(input, auth) {
+    try {
+        const { id, resolverPayload } = input;
+        if (!resolverPayload) {
+            return { status: 400, error: 'resolverPayload is required' };
+        }
+        // 1. Read escalation (verify pending)
+        const escalation = await escalationService.getEscalation(id);
+        if (!escalation) {
+            return { status: 404, error: 'Escalation not found' };
+        }
+        if (escalation.status !== 'pending') {
+            return { status: 409, error: 'Escalation not available for resolution' };
+        }
+        // 2. waitFor signal escalation -- signal the paused workflow directly
+        const signalRouting = escalation.metadata?.signal_routing;
+        if (signalRouting?.signalId) {
+            // Replace password fields with ephemeral tokens so plaintext never enters the signal store
+            let signalPayload = resolverPayload;
+            const formSchema = escalation.metadata?.form_schema;
+            if (formSchema?.properties) {
+                signalPayload = { ...resolverPayload };
+                for (const [key, def] of Object.entries(formSchema.properties)) {
+                    if (def?.format === 'password' && typeof signalPayload[key] === 'string') {
+                        const uuid = await (0, ephemeral_1.storeEphemeral)(signalPayload[key], {
+                            ttlSeconds: 900,
+                            label: key,
+                        });
+                        signalPayload[key] = (0, ephemeral_1.formatEphemeralToken)(uuid, key);
+                    }
+                }
+            }
+            if (signalRouting.engine === 'yaml' && signalRouting.hookTopic && signalRouting.appId) {
+                const engine = await (0, deployer_1.getEngine)(signalRouting.appId);
+                await engine.signal(signalRouting.hookTopic, {
+                    ...signalPayload,
+                    escalationId: escalation.id,
+                    job_id: signalRouting.jobId,
+                });
+            }
+            else if (signalRouting.workflowId) {
+                const client = (0, workers_1.createClient)();
+                const handle = await client.workflow.getHandle(signalRouting.taskQueue, signalRouting.workflowType, signalRouting.workflowId);
+                await handle.signal(signalRouting.signalId, signalPayload);
+            }
+            await escalationService.resolveEscalation(escalation.id, resolverPayload);
+            (0, publish_1.publishEscalationEvent)({
+                type: 'escalation.resolved',
+                source: 'api',
+                workflowId: escalation.workflow_id || signalRouting.workflowId,
+                workflowName: escalation.workflow_type || signalRouting.workflowType,
+                taskQueue: escalation.task_queue || signalRouting.taskQueue || signalRouting.appId,
+                taskId: escalation.task_id,
+                escalationId: escalation.id,
+                originId: escalation.origin_id ?? undefined,
+                status: 'resolved',
+            });
+            return {
+                status: 200,
+                data: {
+                    signaled: true,
+                    escalationId: escalation.id,
+                    workflowId: signalRouting.workflowId || signalRouting.appId,
+                },
+            };
+        }
+        // 3. Reconstruct the original envelope from the escalation or task
+        let envelope = {};
+        if (escalation.envelope) {
+            try {
+                envelope = JSON.parse(escalation.envelope);
+            }
+            catch { /* use empty */ }
+        }
+        else if (escalation.task_id) {
+            const task = await taskService.getTask(escalation.task_id);
+            if (task?.envelope) {
+                try {
+                    envelope = JSON.parse(task.envelope);
+                }
+                catch { /* use empty */ }
+            }
+        }
+        // 4. Check escalation strategy for triage routing
+        const strategy = escalation_strategy_1.escalationStrategyRegistry.current;
+        if (strategy) {
+            const directive = await strategy.onResolution({
+                escalation,
+                resolverPayload,
+                envelope,
+            });
+            if (directive.action === 'triage') {
+                const originalTask = escalation.task_id
+                    ? await taskService.getTask(escalation.task_id)
+                    : null;
+                const routing = originalTask?.metadata;
+                const triageWorkflowId = `triage-${escalation.id}-${Date.now()}`;
+                const client = (0, workers_1.createClient)();
+                await taskService.createTask({
+                    workflow_id: triageWorkflowId,
+                    workflow_type: 'mcpTriageRouter',
+                    lt_type: 'mcpTriage',
+                    task_queue: 'long-tail-system',
+                    signal_id: `lt-triage-${triageWorkflowId}`,
+                    parent_workflow_id: triageWorkflowId,
+                    origin_id: escalation.origin_id || triageWorkflowId,
+                    parent_id: escalation.parent_id ?? undefined,
+                    envelope: JSON.stringify(directive.triageEnvelope),
+                });
+                await client.workflow.start({
+                    workflowName: 'mcpTriageRouter',
+                    args: [directive.triageEnvelope],
+                    taskQueue: 'long-tail-system',
+                    workflowId: triageWorkflowId,
+                    expire: defaults_1.JOB_EXPIRE_SECS,
+                    entity: 'mcpTriageRouter',
+                });
+                await escalationService.resolveEscalation(escalation.id, {
+                    ...resolverPayload,
+                    _lt: { ...resolverPayload._lt, triaged: true, triageWorkflowId },
+                });
+                (0, publish_1.publishEscalationEvent)({
+                    type: 'escalation.resolved',
+                    source: 'api',
+                    workflowId: escalation.workflow_id,
+                    workflowName: escalation.workflow_type,
+                    taskQueue: escalation.task_queue,
+                    taskId: escalation.task_id,
+                    escalationId: escalation.id,
+                    originId: escalation.origin_id ?? undefined,
+                    status: 'resolved',
+                });
+                return {
+                    status: 200,
+                    data: {
+                        started: true,
+                        escalationId: escalation.id,
+                        workflowId: triageWorkflowId,
+                        triage: true,
+                    },
+                };
+            }
+        }
+        // 5. If no workflow_type, this is a notification-only escalation -- acknowledge and close
+        if (!escalation.workflow_type || !escalation.task_queue) {
+            await escalationService.resolveEscalation(escalation.id, resolverPayload);
+            return { status: 200, data: { acknowledged: true, escalationId: escalation.id } };
+        }
+        // 6. Standard re-run: inject resolver data and start original workflow
+        envelope.resolver = resolverPayload;
+        envelope.lt = {
+            ...envelope.lt,
+            escalationId: escalation.id,
+        };
+        const newWorkflowId = `rerun-${escalation.id}-${Date.now()}`;
+        const client = (0, workers_1.createClient)();
+        await client.workflow.start({
+            workflowName: escalation.workflow_type,
+            args: [envelope],
+            taskQueue: escalation.task_queue,
+            workflowId: newWorkflowId,
+            expire: 180,
+        });
+        (0, publish_1.publishEscalationEvent)({
+            type: 'escalation.resolved',
+            source: 'api',
+            workflowId: escalation.workflow_id,
+            workflowName: escalation.workflow_type,
+            taskQueue: escalation.task_queue,
+            taskId: escalation.task_id,
+            escalationId: escalation.id,
+            originId: escalation.origin_id ?? undefined,
+            status: 'resolved',
+        });
+        return {
+            status: 200,
+            data: { started: true, escalationId: escalation.id, workflowId: newWorkflowId },
+        };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// ── Triage workflow launcher (shared by bulkTriage) ────────────────────────
+async function startTriageWorkflow(escalation, hint, userId, client) {
+    let escalationPayload = {};
+    if (escalation.escalation_payload) {
+        try {
+            escalationPayload = JSON.parse(escalation.escalation_payload);
+        }
+        catch { }
+    }
+    let envelope = {};
+    if (escalation.envelope) {
+        try {
+            envelope = JSON.parse(escalation.envelope);
+        }
+        catch { }
+    }
+    const triageWorkflowId = `triage-${escalation.id}-${Date.now()}`;
+    const triageEnvelope = {
+        data: {
+            escalationId: escalation.id,
+            originId: escalation.origin_id ?? undefined,
+            originalWorkflowType: escalation.workflow_type,
+            originalTaskQueue: escalation.task_queue,
+            originalTaskId: escalation.task_id,
+            escalationPayload,
+            resolverPayload: {
+                _lt: { needsTriage: true, ...(hint ? { hint } : {}) },
+            },
+        },
+        metadata: envelope.metadata || {},
+        lt: { ...(envelope.lt || {}), userId },
+    };
+    const routing = escalation.task_id
+        ? (await taskService.getTask(escalation.task_id))?.metadata
+        : null;
+    await taskService.createTask({
+        workflow_id: triageWorkflowId,
+        workflow_type: 'mcpTriage',
+        lt_type: 'mcpTriage',
+        task_queue: 'long-tail-system',
+        signal_id: `lt-triage-${triageWorkflowId}`,
+        parent_workflow_id: routing?.parentWorkflowId || triageWorkflowId,
+        origin_id: escalation.origin_id || triageWorkflowId,
+        parent_id: escalation.parent_id ?? undefined,
+        envelope: JSON.stringify(triageEnvelope),
+        metadata: routing || undefined,
+    });
+    await client.workflow.start({
+        workflowName: 'mcpTriage',
+        args: [triageEnvelope],
+        taskQueue: 'long-tail-system',
+        workflowId: triageWorkflowId,
+        expire: defaults_1.JOB_EXPIRE_SECS,
+        entity: 'mcpTriage',
+    });
+    return triageWorkflowId;
+}

package/build/api/exports.d.ts

@@ -0,0 +1,32 @@
+import type { LTApiResult } from '../types/sdk';
+import type { LTExportField } from '../types';
+import type { ExportMode } from '@hotmeshio/hotmesh/build/types/exporter';
+export declare function listJobs(input: {
+    limit?: number;
+    offset?: number;
+    entity?: string;
+    search?: string;
+    status?: string;
+    sort_by?: string;
+    order?: string;
+    registered?: string;
+}): Promise<LTApiResult>;
+export declare function exportWorkflowState(input: {
+    workflowId: string;
+    allow?: LTExportField[];
+    block?: LTExportField[];
+    values?: boolean;
+}): Promise<LTApiResult>;
+export declare function exportWorkflowExecution(input: {
+    workflowId: string;
+    excludeSystem?: boolean;
+    omitResults?: boolean;
+    mode?: ExportMode;
+    maxDepth?: number;
+}): Promise<LTApiResult>;
+export declare function getWorkflowStatus(input: {
+    workflowId: string;
+}): Promise<LTApiResult>;
+export declare function getWorkflowState(input: {
+    workflowId: string;
+}): Promise<LTApiResult>;