@hotmeshio/long-tail 0.1.6 → 0.1.8

package/build/api/exports.d.ts

@@ -0,0 +1,90 @@
+import type { LTApiResult } from '../types/sdk';
+import type { LTExportField } from '../types';
+import type { ExportMode } from '@hotmeshio/hotmesh/build/types/exporter';
+/**
+ * List export jobs with optional filtering, sorting, and pagination.
+ *
+ * @param input.limit — maximum number of jobs to return
+ * @param input.offset — number of jobs to skip for pagination
+ * @param input.entity — filter by entity/workflow type
+ * @param input.search — free-text search across job fields
+ * @param input.status — filter by job status
+ * @param input.sort_by — field name to sort results by
+ * @param input.order — sort direction (asc or desc)
+ * @param input.registered — filter by registration status
+ * @returns `{ status: 200, data: { jobs, total, ... } }` on success
+ */
+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 the stored state (hash data) of a workflow.
+ *
+ * Resolves the workflow handle from its ID, then exports its state fields.
+ * Fields can be filtered via allow/block lists. Returns 404 if the workflow
+ * cannot be found or its data has expired.
+ *
+ * @param input.workflowId — the workflow's unique identifier
+ * @param input.allow — whitelist of field names to include in the export
+ * @param input.block — blacklist of field names to exclude from the export
+ * @param input.values — when true, include field values (not just field names)
+ * @returns `{ status: 200, data: ExportedState }` on success
+ */
+export declare function exportWorkflowState(input: {
+    workflowId: string;
+    allow?: LTExportField[];
+    block?: LTExportField[];
+    values?: boolean;
+}): Promise<LTApiResult>;
+/**
+ * Export the full execution tree of a workflow.
+ *
+ * Resolves the workflow handle, then exports its execution graph including
+ * activity inputs and results. Returns 404 if the workflow cannot be found
+ * or its data has expired.
+ *
+ * @param input.workflowId — the workflow's unique identifier
+ * @param input.excludeSystem — when true, omit system-generated activities from the export
+ * @param input.omitResults — when true, exclude activity result payloads
+ * @param input.mode — export mode controlling output format (e.g., tree, flat)
+ * @param input.maxDepth — maximum depth to traverse in the execution tree
+ * @returns `{ status: 200, data: ExecutionExport }` on success
+ */
+export declare function exportWorkflowExecution(input: {
+    workflowId: string;
+    excludeSystem?: boolean;
+    omitResults?: boolean;
+    mode?: ExportMode;
+    maxDepth?: number;
+}): Promise<LTApiResult>;
+/**
+ * Get the current status of a workflow (e.g., running, completed, failed).
+ *
+ * Resolves the workflow handle, then queries its status. Returns 404 if the
+ * workflow cannot be found or its data has expired.
+ *
+ * @param input.workflowId — the workflow's unique identifier
+ * @returns `{ status: 200, data: WorkflowStatus }` on success
+ */
+export declare function getWorkflowStatus(input: {
+    workflowId: string;
+}): Promise<LTApiResult>;
+/**
+ * Get the current state data of a workflow.
+ *
+ * Resolves the workflow handle, then retrieves its full state. Returns 404
+ * if the workflow cannot be found or its data has expired.
+ *
+ * @param input.workflowId — the workflow's unique identifier
+ * @returns `{ status: 200, data: WorkflowState }` on success
+ */
+export declare function getWorkflowState(input: {
+    workflowId: string;
+}): Promise<LTApiResult>;

package/build/api/exports.js

@@ -0,0 +1,204 @@
+"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.listJobs = listJobs;
+exports.exportWorkflowState = exportWorkflowState;
+exports.exportWorkflowExecution = exportWorkflowExecution;
+exports.getWorkflowStatus = getWorkflowStatus;
+exports.getWorkflowState = getWorkflowState;
+const exportService = __importStar(require("../services/export"));
+const resolve_1 = require("../services/task/resolve");
+/**
+ * List export jobs with optional filtering, sorting, and pagination.
+ *
+ * @param input.limit — maximum number of jobs to return
+ * @param input.offset — number of jobs to skip for pagination
+ * @param input.entity — filter by entity/workflow type
+ * @param input.search — free-text search across job fields
+ * @param input.status — filter by job status
+ * @param input.sort_by — field name to sort results by
+ * @param input.order — sort direction (asc or desc)
+ * @param input.registered — filter by registration status
+ * @returns `{ status: 200, data: { jobs, total, ... } }` on success
+ */
+async function listJobs(input) {
+    try {
+        const result = await exportService.listJobs(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Export the stored state (hash data) of a workflow.
+ *
+ * Resolves the workflow handle from its ID, then exports its state fields.
+ * Fields can be filtered via allow/block lists. Returns 404 if the workflow
+ * cannot be found or its data has expired.
+ *
+ * @param input.workflowId — the workflow's unique identifier
+ * @param input.allow — whitelist of field names to include in the export
+ * @param input.block — blacklist of field names to exclude from the export
+ * @param input.values — when true, include field values (not just field names)
+ * @returns `{ status: 200, data: ExportedState }` on success
+ */
+async function exportWorkflowState(input) {
+    try {
+        let resolved;
+        try {
+            resolved = await (0, resolve_1.resolveWorkflowHandle)(input.workflowId);
+        }
+        catch {
+            return { status: 404, error: 'Workflow not found' };
+        }
+        const exported = await exportService.exportWorkflow(input.workflowId, resolved.taskQueue, resolved.workflowName, { allow: input.allow, block: input.block, values: input.values });
+        return { status: 200, data: exported };
+    }
+    catch (err) {
+        const msg = err.message ?? '';
+        if (msg.includes('not found') || msg.includes('undefined')) {
+            return {
+                status: 404,
+                error: 'Workflow data is no longer available (job may have expired)',
+            };
+        }
+        return { status: 500, error: msg };
+    }
+}
+/**
+ * Export the full execution tree of a workflow.
+ *
+ * Resolves the workflow handle, then exports its execution graph including
+ * activity inputs and results. Returns 404 if the workflow cannot be found
+ * or its data has expired.
+ *
+ * @param input.workflowId — the workflow's unique identifier
+ * @param input.excludeSystem — when true, omit system-generated activities from the export
+ * @param input.omitResults — when true, exclude activity result payloads
+ * @param input.mode — export mode controlling output format (e.g., tree, flat)
+ * @param input.maxDepth — maximum depth to traverse in the execution tree
+ * @returns `{ status: 200, data: ExecutionExport }` on success
+ */
+async function exportWorkflowExecution(input) {
+    try {
+        let resolved;
+        try {
+            resolved = await (0, resolve_1.resolveWorkflowHandle)(input.workflowId);
+        }
+        catch {
+            return { status: 404, error: 'Workflow not found' };
+        }
+        const execution = await exportService.exportWorkflowExecution(input.workflowId, resolved.taskQueue, resolved.workflowName, {
+            exclude_system: input.excludeSystem ?? false,
+            omit_results: input.omitResults ?? false,
+            mode: input.mode || undefined,
+            max_depth: input.maxDepth,
+            enrich_inputs: true,
+        });
+        return { status: 200, data: execution };
+    }
+    catch (err) {
+        const status = err.status === 404 || err.message?.includes('Not Found') ? 404 : 500;
+        return {
+            status,
+            error: status === 404
+                ? 'Workflow data is no longer available (job may have expired)'
+                : err.message,
+        };
+    }
+}
+/**
+ * Get the current status of a workflow (e.g., running, completed, failed).
+ *
+ * Resolves the workflow handle, then queries its status. Returns 404 if the
+ * workflow cannot be found or its data has expired.
+ *
+ * @param input.workflowId — the workflow's unique identifier
+ * @returns `{ status: 200, data: WorkflowStatus }` on success
+ */
+async function getWorkflowStatus(input) {
+    try {
+        let resolved;
+        try {
+            resolved = await (0, resolve_1.resolveWorkflowHandle)(input.workflowId);
+        }
+        catch {
+            return { status: 404, error: 'Workflow not found' };
+        }
+        const result = await exportService.getWorkflowStatus(input.workflowId, resolved.taskQueue, resolved.workflowName);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        const status = err.status === 404 || err.message?.includes('Not Found') ? 404 : 500;
+        return {
+            status,
+            error: status === 404
+                ? 'Workflow data is no longer available (job may have expired)'
+                : err.message,
+        };
+    }
+}
+/**
+ * Get the current state data of a workflow.
+ *
+ * Resolves the workflow handle, then retrieves its full state. Returns 404
+ * if the workflow cannot be found or its data has expired.
+ *
+ * @param input.workflowId — the workflow's unique identifier
+ * @returns `{ status: 200, data: WorkflowState }` on success
+ */
+async function getWorkflowState(input) {
+    try {
+        let resolved;
+        try {
+            resolved = await (0, resolve_1.resolveWorkflowHandle)(input.workflowId);
+        }
+        catch {
+            return { status: 404, error: 'Workflow not found' };
+        }
+        const result = await exportService.getWorkflowState(input.workflowId, resolved.taskQueue, resolved.workflowName);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        const status = err.status === 404 || err.message?.includes('Not Found') ? 404 : 500;
+        return {
+            status,
+            error: status === 404
+                ? 'Workflow data is no longer available (job may have expired)'
+                : err.message,
+        };
+    }
+}

package/build/api/index.d.ts

@@ -0,0 +1,18 @@
+export * as tasks from './tasks';
+export * as escalations from './escalations';
+export * as workflows from './workflows';
+export * as yamlWorkflows from './yaml-workflows';
+export * as users from './users';
+export * as roles from './roles';
+export * as auth from './auth';
+export * as mcp from './mcp';
+export * as mcpRuns from './mcp-runs';
+export * as insight from './insight';
+export * as settings from './settings';
+export * as exports from './exports';
+export * as controlplane from './controlplane';
+export * as botAccounts from './bot-accounts';
+export * as workflowSets from './workflow-sets';
+export * as dba from './dba';
+export * as namespaces from './namespaces';
+export * as maintenance from './maintenance';

package/build/api/index.js

@@ -0,0 +1,54 @@
+"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.maintenance = exports.namespaces = exports.dba = exports.workflowSets = exports.botAccounts = exports.controlplane = exports.exports = exports.settings = exports.insight = exports.mcpRuns = exports.mcp = exports.auth = exports.roles = exports.users = exports.yamlWorkflows = exports.workflows = exports.escalations = exports.tasks = void 0;
+exports.tasks = __importStar(require("./tasks"));
+exports.escalations = __importStar(require("./escalations"));
+exports.workflows = __importStar(require("./workflows"));
+exports.yamlWorkflows = __importStar(require("./yaml-workflows"));
+exports.users = __importStar(require("./users"));
+exports.roles = __importStar(require("./roles"));
+exports.auth = __importStar(require("./auth"));
+exports.mcp = __importStar(require("./mcp"));
+exports.mcpRuns = __importStar(require("./mcp-runs"));
+exports.insight = __importStar(require("./insight"));
+exports.settings = __importStar(require("./settings"));
+exports.exports = __importStar(require("./exports"));
+exports.controlplane = __importStar(require("./controlplane"));
+exports.botAccounts = __importStar(require("./bot-accounts"));
+exports.workflowSets = __importStar(require("./workflow-sets"));
+exports.dba = __importStar(require("./dba"));
+exports.namespaces = __importStar(require("./namespaces"));
+exports.maintenance = __importStar(require("./maintenance"));

package/build/api/insight.d.ts

@@ -0,0 +1,86 @@
+import type { LTApiResult, LTApiAuth } from '../types/sdk';
+/**
+ * Execute a natural-language query against connected MCP servers.
+ *
+ * Requires an LLM API key (OPENAI_API_KEY or ANTHROPIC_API_KEY) to be
+ * configured. Returns 503 if neither is set. Timeouts surface as 504.
+ *
+ * @param input.prompt — the natural-language query to execute (required)
+ * @param input.tags — optional tags to scope which MCP servers are queried
+ * @param input.wait — when true, blocks until the query completes; otherwise returns immediately
+ * @param input.direct — when true, bypasses workflow orchestration and queries the LLM directly
+ * @param input.context — optional additional context forwarded to the LLM
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { ... } }` query result from the MCP pipeline
+ */
+export declare function mcpQuery(input: {
+    prompt: string;
+    tags?: string[];
+    wait?: boolean;
+    direct?: boolean;
+    context?: any;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+/**
+ * Generate a workflow definition from a natural-language description.
+ *
+ * Uses an LLM to produce a YAML workflow from the given prompt. Supports
+ * iterative refinement by accepting prior YAML, feedback, and Q&A answers.
+ * Requires an LLM API key. Timeouts surface as 504.
+ *
+ * @param input.prompt — natural-language description of the desired workflow (required)
+ * @param input.tags — optional tags to scope available MCP tools
+ * @param input.wait — when true, blocks until generation completes
+ * @param input.feedback — optional refinement feedback on a previous generation
+ * @param input.prior_yaml — optional YAML from a previous generation to refine
+ * @param input.answers — optional answers to clarifying questions from a prior round
+ * @param input.prior_questions — optional questions from a prior round for context
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { ... } }` generated workflow definition
+ */
+export declare function buildWorkflow(input: {
+    prompt: string;
+    tags?: string[];
+    wait?: boolean;
+    feedback?: string;
+    prior_yaml?: string;
+    answers?: any;
+    prior_questions?: any;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+/**
+ * Refine an existing workflow definition using feedback.
+ *
+ * Takes a previously generated YAML workflow, the original prompt, and
+ * user feedback, then produces an updated workflow definition.
+ *
+ * @param input.prompt — original natural-language description (required)
+ * @param input.prior_yaml — the YAML workflow to refine (required)
+ * @param input.feedback — user feedback describing desired changes (required)
+ * @param input.tags — optional tags to scope available MCP tools
+ * @param input.wait — when true, blocks until refinement completes
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { ... } }` refined workflow definition
+ */
+export declare function refineWorkflow(input: {
+    prompt: string;
+    prior_yaml: string;
+    feedback: string;
+    tags?: string[];
+    wait?: boolean;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+/**
+ * Generate a human-readable description and tags for a workflow.
+ *
+ * Uses an LLM to produce a concise description from the prompt and
+ * optional result metadata. Falls back to the raw prompt as the
+ * description if the LLM call fails.
+ *
+ * @param input.prompt — the workflow prompt or content to describe (required)
+ * @param input.result_title — optional title from the workflow result for additional context
+ * @param input.result_summary — optional summary from the workflow result for additional context
+ * @returns `{ status: 200, data: { description, tags } }` generated description and tag array
+ */
+export declare function describeWorkflow(input: {
+    prompt: string;
+    result_title?: string;
+    result_summary?: string;
+}): Promise<LTApiResult>;

package/build/api/insight.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpQuery = mcpQuery;
+exports.buildWorkflow = buildWorkflow;
+exports.refineWorkflow = refineWorkflow;
+exports.describeWorkflow = describeWorkflow;
+const insight_1 = require("../services/insight");
+/**
+ * Execute a natural-language query against connected MCP servers.
+ *
+ * Requires an LLM API key (OPENAI_API_KEY or ANTHROPIC_API_KEY) to be
+ * configured. Returns 503 if neither is set. Timeouts surface as 504.
+ *
+ * @param input.prompt — the natural-language query to execute (required)
+ * @param input.tags — optional tags to scope which MCP servers are queried
+ * @param input.wait — when true, blocks until the query completes; otherwise returns immediately
+ * @param input.direct — when true, bypasses workflow orchestration and queries the LLM directly
+ * @param input.context — optional additional context forwarded to the LLM
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { ... } }` query result from the MCP pipeline
+ */
+async function mcpQuery(input, auth) {
+    try {
+        if (!input.prompt || typeof input.prompt !== 'string') {
+            return { status: 400, error: 'prompt is required' };
+        }
+        if (!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+            return { status: 503, error: 'MCP queries require an LLM API key (OPENAI_API_KEY or ANTHROPIC_API_KEY)' };
+        }
+        const result = await (0, insight_1.startMcpQuery)({
+            prompt: input.prompt,
+            tags: input.tags,
+            wait: input.wait,
+            direct: input.direct,
+            context: input.context,
+            userId: auth?.userId,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        if (err.message?.includes('timeout') || err.message?.includes('TIMEOUT')) {
+            return { status: 504, error: 'MCP query timed out. Try a simpler prompt.' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Generate a workflow definition from a natural-language description.
+ *
+ * Uses an LLM to produce a YAML workflow from the given prompt. Supports
+ * iterative refinement by accepting prior YAML, feedback, and Q&A answers.
+ * Requires an LLM API key. Timeouts surface as 504.
+ *
+ * @param input.prompt — natural-language description of the desired workflow (required)
+ * @param input.tags — optional tags to scope available MCP tools
+ * @param input.wait — when true, blocks until generation completes
+ * @param input.feedback — optional refinement feedback on a previous generation
+ * @param input.prior_yaml — optional YAML from a previous generation to refine
+ * @param input.answers — optional answers to clarifying questions from a prior round
+ * @param input.prior_questions — optional questions from a prior round for context
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { ... } }` generated workflow definition
+ */
+async function buildWorkflow(input, auth) {
+    try {
+        if (!input.prompt || typeof input.prompt !== 'string') {
+            return { status: 400, error: 'prompt is required' };
+        }
+        if (!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+            return { status: 503, error: 'Workflow builder requires an LLM API key (OPENAI_API_KEY or ANTHROPIC_API_KEY)' };
+        }
+        const result = await (0, insight_1.startWorkflowBuilder)({
+            prompt: input.prompt,
+            tags: input.tags,
+            wait: input.wait,
+            feedback: input.feedback,
+            prior_yaml: input.prior_yaml,
+            answers: input.answers,
+            prior_questions: input.prior_questions,
+            userId: auth?.userId,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        if (err.message?.includes('timeout') || err.message?.includes('TIMEOUT')) {
+            return { status: 504, error: 'Workflow builder timed out. Try a simpler description.' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Refine an existing workflow definition using feedback.
+ *
+ * Takes a previously generated YAML workflow, the original prompt, and
+ * user feedback, then produces an updated workflow definition.
+ *
+ * @param input.prompt — original natural-language description (required)
+ * @param input.prior_yaml — the YAML workflow to refine (required)
+ * @param input.feedback — user feedback describing desired changes (required)
+ * @param input.tags — optional tags to scope available MCP tools
+ * @param input.wait — when true, blocks until refinement completes
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { ... } }` refined workflow definition
+ */
+async function refineWorkflow(input, auth) {
+    try {
+        if (!input.prompt || !input.prior_yaml || !input.feedback) {
+            return { status: 400, error: 'prompt, prior_yaml, and feedback are required' };
+        }
+        const result = await (0, insight_1.startWorkflowBuilder)({
+            prompt: input.prompt,
+            tags: input.tags,
+            wait: input.wait,
+            feedback: input.feedback,
+            prior_yaml: input.prior_yaml,
+            userId: auth?.userId,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Generate a human-readable description and tags for a workflow.
+ *
+ * Uses an LLM to produce a concise description from the prompt and
+ * optional result metadata. Falls back to the raw prompt as the
+ * description if the LLM call fails.
+ *
+ * @param input.prompt — the workflow prompt or content to describe (required)
+ * @param input.result_title — optional title from the workflow result for additional context
+ * @param input.result_summary — optional summary from the workflow result for additional context
+ * @returns `{ status: 200, data: { description, tags } }` generated description and tag array
+ */
+async function describeWorkflow(input) {
+    try {
+        if (!input.prompt) {
+            return { status: 400, error: 'prompt is required' };
+        }
+        const result = await (0, insight_1.describeWorkflow)(input);
+        return { status: 200, data: result };
+    }
+    catch {
+        return { status: 200, data: { description: input.prompt || '', tags: [] } };
+    }
+}

package/build/api/maintenance.d.ts

@@ -0,0 +1,22 @@
+import type { LTMaintenanceConfig } from '../types/maintenance';
+import type { LTApiResult } from '../types/sdk';
+/**
+ * Return the current maintenance cron configuration and active state.
+ *
+ * @returns `{ status: 200, data: { config, active } }`
+ */
+export declare function getMaintenanceConfig(): LTApiResult;
+/**
+ * Replace the maintenance configuration and restart the cron.
+ *
+ * Disconnects the current maintenance schedule, registers the new
+ * config, and reconnects. The cron begins executing immediately.
+ *
+ * @param input.schedule — cron expression (e.g. `"0 3 * * *"`)
+ * @param input.rules — maintenance rule definitions
+ * @returns `{ status: 200, data: { config, restarted: true } }`
+ */
+export declare function updateMaintenanceConfig(input: {
+    schedule: string;
+    rules: LTMaintenanceConfig['rules'];
+}): Promise<LTApiResult>;

package/build/api/maintenance.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaintenanceConfig = getMaintenanceConfig;
+exports.updateMaintenanceConfig = updateMaintenanceConfig;
+const maintenance_1 = require("../services/maintenance");
+/**
+ * Return the current maintenance cron configuration and active state.
+ *
+ * @returns `{ status: 200, data: { config, active } }`
+ */
+function getMaintenanceConfig() {
+    return {
+        status: 200,
+        data: { config: maintenance_1.maintenanceRegistry.config, active: maintenance_1.maintenanceRegistry.hasConfig },
+    };
+}
+/**
+ * Replace the maintenance configuration and restart the cron.
+ *
+ * Disconnects the current maintenance schedule, registers the new
+ * config, and reconnects. The cron begins executing immediately.
+ *
+ * @param input.schedule — cron expression (e.g. `"0 3 * * *"`)
+ * @param input.rules — maintenance rule definitions
+ * @returns `{ status: 200, data: { config, restarted: true } }`
+ */
+async function updateMaintenanceConfig(input) {
+    try {
+        if (!input.schedule || !Array.isArray(input.rules)) {
+            return { status: 400, error: 'schedule (string) and rules (array) are required' };
+        }
+        await maintenance_1.maintenanceRegistry.disconnect();
+        maintenance_1.maintenanceRegistry.register({ schedule: input.schedule, rules: input.rules });
+        await maintenance_1.maintenanceRegistry.connect();
+        return {
+            status: 200,
+            data: { config: maintenance_1.maintenanceRegistry.config, restarted: true },
+        };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}