@hotmeshio/long-tail 0.1.13 → 0.1.15

package/build/api/{yaml-workflows.js → yaml-workflows/crud.js}

@@ -41,31 +41,14 @@ exports.getYamlWorkflow = getYamlWorkflow;
 exports.updateYamlWorkflow = updateYamlWorkflow;
 exports.regenerateYamlWorkflow = regenerateYamlWorkflow;
 exports.deleteYamlWorkflow = deleteYamlWorkflow;
-exports.deployYamlWorkflow = deployYamlWorkflow;
-exports.activateYamlWorkflow = activateYamlWorkflow;
-exports.invokeYamlWorkflow = invokeYamlWorkflow;
-exports.archiveYamlWorkflow = archiveYamlWorkflow;
-exports.getVersionHistory = getVersionHistory;
-exports.getVersionSnapshot = getVersionSnapshot;
-exports.getYamlContent = getYamlContent;
-exports.setCronSchedule = setCronSchedule;
-exports.clearCronSchedule = clearCronSchedule;
-exports.getCronStatus = getCronStatus;
-const yamlDb = __importStar(require("../services/yaml-workflow/db"));
-const yamlGenerator = __importStar(require("../services/yaml-workflow/generator"));
-const yamlDeployer = __importStar(require("../services/yaml-workflow/deployer"));
-const yamlWorkers = __importStar(require("../services/yaml-workflow/workers"));
-const invoke_1 = require("../services/yaml-workflow/invoke");
-const task_1 = require("../services/task");
-const cron_1 = require("../services/cron");
-/** Return true if a Postgres error indicates an invalid/missing ID */
-function isNotFoundError(err) {
-    const msg = err?.message ?? '';
-    return msg.includes('invalid input syntax for type uuid') || msg.includes('not found');
-}
-// ---------------------------------------------------------------------------
-// CRUD
-// ---------------------------------------------------------------------------
+exports.createYamlWorkflowFromDurable = createYamlWorkflowFromDurable;
+const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
+const yamlGenerator = __importStar(require("../../services/yaml-workflow/generator"));
+const durable_compiler_1 = require("../../services/yaml-workflow/durable-compiler");
+const builder_regenerate_1 = require("../../services/yaml-workflow/builder-regenerate");
+const task_1 = require("../../services/task");
+const utils_1 = require("../../modules/utils");
+const helpers_1 = require("./helpers");
 /**
  * List YAML workflows with optional filtering and pagination.
  *
@@ -96,7 +79,7 @@ async function listYamlWorkflows(input) {
         return { status: 200, data: result };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
@@ -143,8 +126,8 @@ async function createYamlWorkflow(input) {
             }
         }
         // Check for topic collision in the target namespace
-        const compileAppId = app_id || 'longtail';
-        const compileTopic = subscribes || name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+        const compileAppId = (0, utils_1.sanitizeServerName)(app_id || 'longtail');
+        const compileTopic = (0, utils_1.sanitizeToolName)(subscribes || name);
         const conflicting = await yamlDb.checkTopicConflict(compileAppId, compileTopic);
         if (conflicting) {
             return {
@@ -220,15 +203,15 @@ async function createYamlWorkflowDirect(input) {
         if (!name || !yaml_content) {
             return { status: 400, error: 'name and yaml_content are required' };
         }
-        // Sanitize name (tool name): lowercase alphanumeric, periods, dashes, underscores
-        const sanitizedName = name.toLowerCase().replace(/[^a-z0-9._-]/g, '');
-        // Sanitize app_id (MCP server name): force lowercase alphanumeric only
-        const targetAppId = (app_id || 'longtail').toLowerCase().replace(/[^a-z0-9]/g, '');
-        // Sanitize graph topic: lowercase alphanumeric, periods, dashes, underscores
-        let graphTopic = (graph_topic || sanitizedName).toLowerCase().replace(/[^a-z0-9._-]/g, '');
+        // Sanitize name (tool name): snake_case only
+        const sanitizedName = (0, utils_1.sanitizeToolName)(name);
+        // Sanitize app_id (MCP server name): lowercase alphanumeric, must start with a letter
+        const targetAppId = (0, utils_1.sanitizeServerName)(app_id || 'longtail');
+        // Sanitize graph topic: snake_case only
+        let graphTopic = (0, utils_1.sanitizeToolName)(graph_topic || sanitizedName);
         const subscribesMatch = yaml_content.match(/subscribes:\s*(.+)/);
         if (subscribesMatch) {
-            graphTopic = subscribesMatch[1].trim().replace(/^['"]|['"]$/g, '').toLowerCase().replace(/[^a-z0-9._-]/g, '');
+            graphTopic = (0, utils_1.sanitizeToolName)(subscribesMatch[1].trim().replace(/^['"]|['"]$/g, ''));
         }
         // Rewrite the subscribes line in the YAML to match the sanitized topic
         let finalYaml = yaml_content;
@@ -299,7 +282,7 @@ async function getYamlWorkflow(input) {
         return { status: 200, data: wf };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
@@ -324,7 +307,7 @@ async function updateYamlWorkflow(input) {
         return { status: 200, data: wf };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
@@ -352,10 +335,32 @@ async function regenerateYamlWorkflow(input) {
         if (wf.status === 'archived') {
             return { status: 400, error: 'Archived workflows cannot be regenerated' };
         }
+        // Plan Build workflows: recompile from original prompt via builder LLM
+        if (!wf.source_workflow_id && wf.source_workflow_type === 'mcpWorkflowPlanner') {
+            if (!wf.original_prompt) {
+                return { status: 400, error: 'Cannot recompile: original prompt not stored. Re-run the plan to rebuild this workflow.' };
+            }
+            const feedback = input.compilation_feedback;
+            const result = await (0, builder_regenerate_1.rebuildFromPrompt)({
+                prompt: wf.original_prompt,
+                feedback: feedback || undefined,
+                priorYaml: feedback ? wf.yaml_content : undefined,
+                name: wf.name,
+                appId: wf.app_id,
+            });
+            const updated = await yamlDb.updateYamlWorkflow(wf.id, {
+                yaml_content: result.yaml,
+                input_schema: result.inputSchema,
+                output_schema: result.outputSchema,
+                activity_manifest: result.activityManifest,
+                tags: result.tags,
+            });
+            return { status: 200, data: updated };
+        }
         if (!wf.source_workflow_id || !wf.source_workflow_type) {
             return { status: 400, error: 'Missing source workflow reference — cannot regenerate' };
         }
-        // Look up task queue from the source task record, or use input override
+        // Execution-trace workflows: recompile from source execution
         let taskQueue = input.task_queue;
         if (!taskQueue) {
             const sourceTask = await (0, task_1.getTaskByWorkflowId)(wf.source_workflow_id);
@@ -385,7 +390,7 @@ async function regenerateYamlWorkflow(input) {
         return { status: 200, data: updated };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
@@ -413,337 +418,60 @@ async function deleteYamlWorkflow(input) {
         return { status: 200, data: { deleted: true } };
     }
     catch (err) {
-        if (isNotFoundError(err)) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
             return { status: 404, error: 'YAML workflow not found' };
         }
         return { status: 500, error: err.message };
     }
 }
-// ---------------------------------------------------------------------------
-// Deployment
-// ---------------------------------------------------------------------------
 /**
- * Deploy a YAML workflow and all sibling workflows sharing its app_id namespace.
+ * Compile a durable TypeScript workflow into a YAML DAG.
  *
- * Merges and deploys the full app_id YAML, registers HotMesh workers for every
- * non-archived sibling, transitions draft/deployed siblings to active, and marks
- * the app_id content as deployed. Uses the app_version declared in the workflow record.
+ * Accepts inline source code or a file path. The LLM translates the procedural
+ * orchestration into an equivalent HotMesh YAML DAG that runs without replay.
  *
- * @param input.id — UUID of the workflow to deploy
- * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after deployment
- */
-async function deployYamlWorkflow(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        // Use the version declared in the YAML (like package.json)
-        const deployVersion = wf.app_version || '1';
-        // Deploy + activate merged YAML for the full app_id
-        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
-        await yamlDeployer.deployAppId(wf.app_id, deployVersion);
-        // Register workers and mark all non-archived siblings as active
-        for (const sibling of siblings) {
-            await yamlDb.updateYamlWorkflowVersion(sibling.id, deployVersion);
-            await yamlWorkers.registerWorkersForWorkflow(sibling);
-            if (sibling.status === 'draft' || sibling.status === 'deployed') {
-                await yamlDb.updateYamlWorkflowStatus(sibling.id, 'active');
-            }
-        }
-        // Mark content as deployed for the entire app_id
-        await yamlDb.markAppIdContentDeployed(wf.app_id);
-        const updated = await yamlDb.getYamlWorkflow(input.id);
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return {
-            status: 500,
-            error: err.message,
-        };
-    }
-}
-/**
- * Activate a previously deployed YAML workflow and its app_id siblings.
- *
- * Calls the deployer to activate the app_id at its current version, then registers
- * HotMesh workers for all sibling workflows. Siblings in "deployed" status are
- * transitioned to "active". The workflow must already be in deployed or active status.
- *
- * @param input.id — UUID of the workflow to activate
- * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after activation
- */
-async function activateYamlWorkflow(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        if (wf.status !== 'deployed' && wf.status !== 'active') {
-            return { status: 400, error: 'Workflow must be deployed before activation' };
-        }
-        await yamlDeployer.activateYamlWorkflow(wf.app_id, wf.app_version);
-        // Register workers for ALL workflows sharing this app_id
-        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
-        for (const sibling of siblings) {
-            await yamlWorkers.registerWorkersForWorkflow(sibling);
-            if (sibling.status === 'deployed') {
-                await yamlDb.updateYamlWorkflowStatus(sibling.id, 'active');
-            }
-        }
-        const updated = await yamlDb.getYamlWorkflow(input.id);
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Invoke an active YAML workflow, executing its DAG pipeline.
- *
- * The workflow must be in "active" status. Delegates to the invoke service which
- * starts the HotMesh execution. Supports both synchronous (wait for result) and
- * asynchronous (fire-and-forget) invocation modes.
- *
- * @param input.id — UUID of the workflow to invoke
- * @param input.data — input payload passed to the workflow's entry point
- * @param input.sync — when true, block until the workflow completes and return its output
- * @param input.timeout — max milliseconds to wait when sync is true
- * @param input.execute_as — override identity for the execution context
- * @param auth — authenticated user context; userId is forwarded to the invoke service
- * @returns `{ status: 200, data: ... }` workflow execution result (sync) or job metadata (async)
+ * @param input.source — TypeScript source code or file path
+ * @param input.is_file_path — whether source is a file path (default: false)
+ * @param input.workflow_name — name of the exported workflow function
+ * @param input.name — name for the generated YAML workflow
+ * @param input.description — optional description
+ * @param input.app_id — target namespace (defaults to "longtail")
+ * @param input.subscribes — graph topic override
+ * @param input.tags — additional tags
+ * @returns `{ status: 201, data: YamlWorkflow }` the newly created draft record
  */
-async function invokeYamlWorkflow(input, auth) {
+async function createYamlWorkflowFromDurable(input) {
     try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        if (wf.status !== 'active') {
-            return { status: 400, error: 'Workflow must be active to invoke' };
+        const { source, workflow_name, name, description, app_id, subscribes, tags: userTags } = input;
+        if (!source || !workflow_name || !name) {
+            return { status: 400, error: 'source, workflow_name, and name are required' };
         }
-        const result = await (0, invoke_1.invokeYamlWorkflow)(wf, {
-            data: input.data,
-            sync: input.sync,
-            timeout: input.timeout,
-            execute_as: input.execute_as,
-            userId: auth?.userId,
+        const result = await (0, durable_compiler_1.compileDurableToYaml)({
+            source,
+            isFilePath: !!input.is_file_path,
+            workflowName: workflow_name,
+            name,
+            description,
+            appId: app_id,
+            subscribes,
         });
-        return { status: 200, data: result };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Archive a YAML workflow, removing it from active service.
- *
- * If the workflow is currently active, its HotMesh engine is stopped before
- * transitioning the status to "archived". Archived workflows cannot be invoked
- * or regenerated but can still be viewed or deleted.
- *
- * @param input.id — UUID of the workflow to archive
- * @returns `{ status: 200, data: YamlWorkflow }` the updated record with status "archived"
- */
-async function archiveYamlWorkflow(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        if (wf.status === 'active') {
-            await yamlDeployer.stopEngine(wf.app_id);
-        }
-        const updated = await yamlDb.updateYamlWorkflowStatus(wf.id, 'archived');
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-// ---------------------------------------------------------------------------
-// Versions
-// ---------------------------------------------------------------------------
-/**
- * Retrieve the version history for a YAML workflow.
- *
- * Returns a paginated list of version snapshots ordered by version number.
- *
- * @param input.id — UUID of the workflow
- * @param input.limit — max versions to return (defaults to 20)
- * @param input.offset — pagination offset (defaults to 0)
- * @returns `{ status: 200, data: VersionSnapshot[] }` paginated version history
- */
-async function getVersionHistory(input) {
-    try {
-        const limit = input.limit ?? 20;
-        const offset = input.offset ?? 0;
-        const result = await yamlDb.getVersionHistory(input.id, limit, offset);
-        return { status: 200, data: result };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Retrieve a specific version snapshot of a YAML workflow.
- *
- * Validates that the version number is a positive integer before querying.
- *
- * @param input.id — UUID of the workflow
- * @param input.version — 1-based version number to retrieve
- * @returns `{ status: 200, data: VersionSnapshot }` the snapshot at the requested version, or 404
- */
-async function getVersionSnapshot(input) {
-    try {
-        const version = input.version;
-        if (isNaN(version) || version < 1) {
-            return { status: 400, error: 'Invalid version number' };
-        }
-        const snapshot = await yamlDb.getVersionSnapshot(input.id, version);
-        if (!snapshot) {
-            return { status: 404, error: `Version ${version} not found` };
-        }
-        return { status: 200, data: snapshot };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Retrieve the raw YAML content for a workflow, optionally at a specific version.
- *
- * When a version is provided, fetches from the version snapshot table. Otherwise
- * returns the current yaml_content from the live workflow record.
- *
- * @param input.id — UUID of the workflow
- * @param input.version — optional version number; when omitted, returns the current content
- * @returns `{ status: 200, data: string }` the raw YAML string
- */
-async function getYamlContent(input) {
-    try {
-        if (input.version) {
-            const snapshot = await yamlDb.getVersionSnapshot(input.id, input.version);
-            if (!snapshot) {
-                return { status: 404, error: `Version ${input.version} not found` };
-            }
-            return { status: 200, data: snapshot.yaml_content };
-        }
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 200, data: wf.yaml_content };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-// ---------------------------------------------------------------------------
-// Cron
-// ---------------------------------------------------------------------------
-/**
- * Set or update the cron schedule for a YAML workflow.
- *
- * Persists the schedule in the DB and restarts the in-process cron timer via the
- * cron registry so the change takes effect immediately.
- *
- * @param input.id — UUID of the workflow to schedule
- * @param input.cron_schedule — cron expression (e.g. "0 * * * *")
- * @param input.cron_envelope — optional payload passed to each scheduled invocation
- * @param input.execute_as — optional identity override for scheduled executions
- * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields set
- */
-async function setCronSchedule(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        if (!input.cron_schedule || typeof input.cron_schedule !== 'string') {
-            return { status: 400, error: 'cron_schedule is required' };
-        }
-        const updated = await yamlDb.updateCronSchedule(wf.id, input.cron_schedule.trim(), input.cron_envelope ?? null, input.execute_as ?? null);
-        if (updated) {
-            await cron_1.cronRegistry.restartYamlCron(updated);
-        }
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * Remove the cron schedule from a YAML workflow.
- *
- * Stops the in-process cron timer first, then clears the schedule fields in the DB.
- *
- * @param input.id — UUID of the workflow to unschedule
- * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields cleared
- */
-async function clearCronSchedule(input) {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(input.id);
-        if (!wf) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        await cron_1.cronRegistry.stopYamlCron(wf.id);
-        const updated = await yamlDb.clearCronSchedule(wf.id);
-        return { status: 200, data: updated };
-    }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { status: 404, error: 'YAML workflow not found' };
-        }
-        return { status: 500, error: err.message };
-    }
-}
-/**
- * List all YAML workflows that have a cron schedule, with their live timer status.
- *
- * Fetches all cron-scheduled workflows from the DB and cross-references with the
- * in-process cron registry to determine which timers are actually running.
- *
- * @returns `{ status: 200, data: { schedules: Array<{ id, name, graph_topic, app_id, cron_schedule, execute_as, active }> } }`
- */
-async function getCronStatus() {
-    try {
-        const workflows = await yamlDb.getCronScheduledWorkflows();
-        const activeTypes = cron_1.cronRegistry.activeWorkflowTypes;
-        const schedules = workflows.map((wf) => ({
-            id: wf.id,
-            name: wf.name,
-            graph_topic: wf.graph_topic,
-            app_id: wf.app_id,
-            cron_schedule: wf.cron_schedule,
-            execute_as: wf.execute_as,
-            active: activeTypes.includes(`yaml:${wf.id}`),
-        }));
-        return { status: 200, data: { schedules } };
+        const mergedTags = [...new Set([...(result.tags || []), ...(Array.isArray(userTags) ? userTags : [])])];
+        const record = await yamlDb.createYamlWorkflow({
+            name,
+            description,
+            app_id: result.appId,
+            yaml_content: result.yaml,
+            graph_topic: result.graphTopic,
+            input_schema: result.inputSchema,
+            output_schema: result.outputSchema,
+            activity_manifest: result.activityManifest,
+            tags: mergedTags,
+            source_workflow_type: 'durable',
+            original_prompt: description,
+            category: result.category,
+            metadata: { durable_source: source.slice(0, 5000) },
+        });
+        return { status: 201, data: record };
     }
     catch (err) {
         return { status: 500, error: err.message };

package/build/api/yaml-workflows/deploy.d.ts

@@ -0,0 +1,71 @@
+import type { LTApiResult, LTApiAuth } from '../../types/sdk';
+/**
+ * Deploy a YAML workflow and all sibling workflows sharing its app_id namespace.
+ *
+ * Merges and deploys the full app_id YAML, registers HotMesh workers for every
+ * non-archived sibling, transitions draft/deployed siblings to active, and marks
+ * the app_id content as deployed. Uses the app_version declared in the workflow record.
+ *
+ * @param input.id — UUID of the workflow to deploy
+ * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after deployment
+ */
+export declare function deployYamlWorkflow(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Activate a previously deployed YAML workflow and its app_id siblings.
+ *
+ * Calls the deployer to activate the app_id at its current version, then registers
+ * HotMesh workers for all sibling workflows. Siblings in "deployed" status are
+ * transitioned to "active". The workflow must already be in deployed or active status.
+ *
+ * @param input.id — UUID of the workflow to activate
+ * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after activation
+ */
+export declare function activateYamlWorkflow(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Invoke an active YAML workflow, executing its DAG pipeline.
+ *
+ * The workflow must be in "active" status. Delegates to the invoke service which
+ * starts the HotMesh execution. Supports both synchronous (wait for result) and
+ * asynchronous (fire-and-forget) invocation modes.
+ *
+ * @param input.id — UUID of the workflow to invoke
+ * @param input.data — input payload passed to the workflow's entry point
+ * @param input.sync — when true, block until the workflow completes and return its output
+ * @param input.timeout — max milliseconds to wait when sync is true
+ * @param input.execute_as — override identity for the execution context
+ * @param auth — authenticated user context; userId is forwarded to the invoke service
+ * @returns `{ status: 200, data: ... }` workflow execution result (sync) or job metadata (async)
+ */
+export declare function invokeYamlWorkflow(input: {
+    id: string;
+    data?: any;
+    sync?: boolean;
+    timeout?: number;
+    execute_as?: string;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+/**
+ * Archive a YAML workflow, removing it from active service.
+ *
+ * If the workflow is currently active, its HotMesh engine is stopped before
+ * transitioning the status to "archived". Archived workflows cannot be invoked
+ * or regenerated but can still be viewed or deleted.
+ *
+ * @param input.id — UUID of the workflow to archive
+ * @returns `{ status: 200, data: YamlWorkflow }` the updated record with status "archived"
+ */
+export declare function archiveYamlWorkflow(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Restore an archived YAML workflow back to draft status.
+ *
+ * Transitions the workflow from "archived" to "draft" so it can be
+ * redeployed. The workflow must be in "archived" status.
+ */
+export declare function restoreYamlWorkflow(input: {
+    id: string;
+}): Promise<LTApiResult>;