@bpmnkit/core 0.0.8

package/dist/bpmn/optimize/naming.js

@@ -0,0 +1,145 @@
+import { buildFlowIndex, isEndEvent, isStartEvent } from "./utils.js";
+// ---------------------------------------------------------------------------
+// Element type sets
+// ---------------------------------------------------------------------------
+const TASK_TYPES = new Set([
+    "serviceTask",
+    "userTask",
+    "businessRuleTask",
+    "scriptTask",
+    "sendTask",
+    "receiveTask",
+    "manualTask",
+    "callActivity",
+]);
+const SUBPROCESS_TYPES = new Set([
+    "subProcess",
+    "adHocSubProcess",
+    "transaction",
+]);
+const DECISION_GATEWAY_TYPES = new Set([
+    "exclusiveGateway",
+    "inclusiveGateway",
+]);
+// ---------------------------------------------------------------------------
+// Naming analyzer
+// ---------------------------------------------------------------------------
+/**
+ * Analyze BPMN naming conventions based on Camunda best practices:
+ * https://docs.camunda.io/docs/components/best-practices/modeling/naming-bpmnkit-elements/
+ */
+export function analyzeNaming(p, _opts) {
+    const findings = [];
+    const processId = p.id;
+    const { bySource, byTarget } = buildFlowIndex(p);
+    for (const el of p.flowElements) {
+        // ── Tasks ────────────────────────────────────────────────────────────
+        if (TASK_TYPES.has(el.type)) {
+            if (!el.name) {
+                findings.push({
+                    id: "naming/unlabeled-task",
+                    category: "naming",
+                    severity: "warning",
+                    message: `Task "${el.id}" (${el.type}) has no name.`,
+                    suggestion: 'Name tasks using "Verb Object" form, e.g. "Verify Invoice", "Send Notification", "Approve Request".',
+                    processId,
+                    elementIds: [el.id],
+                });
+            }
+        }
+        if (SUBPROCESS_TYPES.has(el.type) && !el.name) {
+            findings.push({
+                id: "naming/unlabeled-subprocess",
+                category: "naming",
+                severity: "info",
+                message: `Sub-process "${el.id}" (${el.type}) has no name.`,
+                suggestion: 'Name sub-processes using "Object + nominalized verb" form, e.g. "Invoice Processing", "Order Fulfillment".',
+                processId,
+                elementIds: [el.id],
+            });
+        }
+        // ── Events ───────────────────────────────────────────────────────────
+        if (isStartEvent(el.type) && !el.name) {
+            findings.push({
+                id: "naming/unlabeled-start-event",
+                category: "naming",
+                severity: "info",
+                message: `Start event "${el.id}" has no name.`,
+                suggestion: 'Name start events using "Object + past participle", e.g. "Order Received", "Payment Initiated".',
+                processId,
+                elementIds: [el.id],
+            });
+        }
+        if (isEndEvent(el.type) && !el.name) {
+            findings.push({
+                id: "naming/unlabeled-end-event",
+                category: "naming",
+                severity: "info",
+                message: `End event "${el.id}" has no name.`,
+                suggestion: 'Name end events using "Object + state", e.g. "Order Fulfilled", "Payment Failed", "Request Rejected".',
+                processId,
+                elementIds: [el.id],
+            });
+        }
+        // ── Decision gateways (XOR / inclusive) ──────────────────────────────
+        if (DECISION_GATEWAY_TYPES.has(el.type)) {
+            const outflows = bySource.get(el.id) ?? [];
+            const inflows = byTarget.get(el.id) ?? [];
+            const isSplit = outflows.length >= 2;
+            const isJoin = inflows.length >= 2;
+            if (isSplit) {
+                // Split gateway must be labeled
+                if (!el.name) {
+                    findings.push({
+                        id: "naming/split-gateway-no-label",
+                        category: "naming",
+                        severity: "warning",
+                        message: `Gateway "${el.id}" (${el.type}, split) has no name.`,
+                        suggestion: 'Label split gateways as a yes/no question, e.g. "Invoice valid?", "Order approved?".',
+                        processId,
+                        elementIds: [el.id],
+                    });
+                }
+                else if (!el.name.trim().endsWith("?")) {
+                    findings.push({
+                        id: "naming/gateway-not-a-question",
+                        category: "naming",
+                        severity: "info",
+                        message: `Gateway "${el.id}" is named "${el.name}" — split gateways should be phrased as questions.`,
+                        suggestion: `Rephrase as a question, e.g. "${el.name.trim()}?"`,
+                        processId,
+                        elementIds: [el.id],
+                    });
+                }
+                // Each outgoing flow must have a condition label
+                for (const flow of outflows) {
+                    if (!flow.name) {
+                        findings.push({
+                            id: "naming/missing-flow-condition",
+                            category: "naming",
+                            severity: "warning",
+                            message: `Sequence flow "${flow.id}" from split gateway "${el.id}" has no condition label.`,
+                            suggestion: 'Label each outgoing flow with the condition answer, e.g. "Yes", "No", "Approved", "Rejected".',
+                            processId,
+                            elementIds: [el.id, flow.id],
+                        });
+                    }
+                }
+            }
+            // Join-only gateways should NOT be labeled
+            if (isJoin && !isSplit && el.name) {
+                findings.push({
+                    id: "naming/join-gateway-labeled",
+                    category: "naming",
+                    severity: "info",
+                    message: `Gateway "${el.id}" (join) is named "${el.name}" — join gateways should not have labels.`,
+                    suggestion: "Remove the label from join-only gateways; their semantics are implicit.",
+                    processId,
+                    elementIds: [el.id],
+                });
+            }
+        }
+    }
+    return findings;
+}
+//# sourceMappingURL=naming.js.map

package/dist/bpmn/optimize/tasks.d.ts

@@ -0,0 +1,4 @@
+import type { BpmnProcess } from "../bpmn-model.js";
+import type { OptimizationFinding, ResolvedOptions } from "./types.js";
+export declare function analyzeTasks(p: BpmnProcess, opts: ResolvedOptions): OptimizationFinding[];
+//# sourceMappingURL=tasks.d.ts.map

package/dist/bpmn/optimize/tasks.js

@@ -0,0 +1,273 @@
+import { generateId } from "../../types/id-generator.js";
+import { findProcess, readZeebeIoMapping, readZeebeTaskHeaders, readZeebeTaskType, } from "./utils.js";
+// ---------------------------------------------------------------------------
+// Similarity scoring
+// ---------------------------------------------------------------------------
+function sameHeaderKeys(a, b) {
+    const ha = readZeebeTaskHeaders(a.extensionElements);
+    const hb = readZeebeTaskHeaders(b.extensionElements);
+    const keysA = new Set((ha?.headers ?? []).map((h) => h.key));
+    const keysB = new Set((hb?.headers ?? []).map((h) => h.key));
+    if (keysA.size !== keysB.size)
+        return false;
+    for (const k of keysA) {
+        if (!keysB.has(k))
+            return false;
+    }
+    return true;
+}
+function sameIoInputs(a, b) {
+    const ia = readZeebeIoMapping(a.extensionElements);
+    const ib = readZeebeIoMapping(b.extensionElements);
+    const inputsA = ia?.inputs ?? [];
+    const inputsB = ib?.inputs ?? [];
+    if (inputsA.length !== inputsB.length)
+        return false;
+    const targetsA = inputsA.map((i) => i.target).sort();
+    const targetsB = inputsB.map((i) => i.target).sort();
+    return targetsA.every((t, idx) => t === targetsB[idx]);
+}
+function sameIoOutputs(a, b) {
+    const ia = readZeebeIoMapping(a.extensionElements);
+    const ib = readZeebeIoMapping(b.extensionElements);
+    const outputsA = ia?.outputs ?? [];
+    const outputsB = ib?.outputs ?? [];
+    if (outputsA.length !== outputsB.length)
+        return false;
+    const targetsA = outputsA.map((o) => o.target).sort();
+    const targetsB = outputsB.map((o) => o.target).sort();
+    return targetsA.every((t, idx) => t === targetsB[idx]);
+}
+/** Returns similarity score [0, 1] or null if taskTypes differ. */
+function computeSimilarity(a, b) {
+    const typeA = readZeebeTaskType(a.extensionElements);
+    const typeB = readZeebeTaskType(b.extensionElements);
+    if (typeA === null || typeB === null || typeA !== typeB)
+        return null;
+    let score = 0.5; // Same taskType
+    if (sameHeaderKeys(a, b))
+        score += 0.2;
+    if (sameIoInputs(a, b))
+        score += 0.15;
+    if (sameIoOutputs(a, b))
+        score += 0.15;
+    return score;
+}
+/** Cluster service tasks into connected components above the similarity threshold. */
+function cluster(tasks, threshold) {
+    const n = tasks.length;
+    const visited = new Array(n).fill(false);
+    const clusters = [];
+    for (let i = 0; i < n; i++) {
+        if (visited[i])
+            continue;
+        const group = [];
+        const queue = [i];
+        visited[i] = true;
+        while (queue.length > 0) {
+            const curr = queue.shift();
+            if (curr === undefined)
+                break;
+            const task = tasks[curr];
+            if (task === undefined)
+                break;
+            group.push(task);
+            for (let j = 0; j < n; j++) {
+                if (visited[j])
+                    continue;
+                const other = tasks[j];
+                if (other === undefined)
+                    continue;
+                const score = computeSimilarity(task, other);
+                if (score !== null && score >= threshold) {
+                    visited[j] = true;
+                    queue.push(j);
+                }
+            }
+        }
+        clusters.push(group);
+    }
+    return clusters;
+}
+// ---------------------------------------------------------------------------
+// Build the extracted BpmnDefinitions
+// ---------------------------------------------------------------------------
+function buildExtractedDefs(representative, newProcessId) {
+    const startId = generateId("StartEvent");
+    const taskId = generateId("ServiceTask");
+    const endId = generateId("EndEvent");
+    const flow1Id = generateId("Flow");
+    const flow2Id = generateId("Flow");
+    const startEvent = {
+        type: "startEvent",
+        id: startId,
+        incoming: [],
+        outgoing: [flow1Id],
+        extensionElements: [],
+        unknownAttributes: {},
+        eventDefinitions: [],
+    };
+    const serviceTask = {
+        type: "serviceTask",
+        id: taskId,
+        name: representative.name,
+        incoming: [flow1Id],
+        outgoing: [flow2Id],
+        extensionElements: [...representative.extensionElements],
+        unknownAttributes: {},
+    };
+    const endEvent = {
+        type: "endEvent",
+        id: endId,
+        incoming: [flow2Id],
+        outgoing: [],
+        extensionElements: [],
+        unknownAttributes: {},
+        eventDefinitions: [],
+    };
+    const extractedProcess = {
+        id: newProcessId,
+        isExecutable: false,
+        extensionElements: [],
+        flowElements: [startEvent, serviceTask, endEvent],
+        sequenceFlows: [
+            {
+                id: flow1Id,
+                sourceRef: startId,
+                targetRef: taskId,
+                extensionElements: [],
+                unknownAttributes: {},
+            },
+            {
+                id: flow2Id,
+                sourceRef: taskId,
+                targetRef: endId,
+                extensionElements: [],
+                unknownAttributes: {},
+            },
+        ],
+        textAnnotations: [],
+        associations: [],
+        unknownAttributes: {},
+    };
+    // Layout: start @ x=152, task @ x=260, end @ x=432, all y=100
+    const startShape = {
+        id: `${startId}_di`,
+        bpmnElement: startId,
+        bounds: { x: 152, y: 100, width: 36, height: 36 },
+        unknownAttributes: {},
+    };
+    const taskShape = {
+        id: `${taskId}_di`,
+        bpmnElement: taskId,
+        bounds: { x: 260, y: 100, width: 100, height: 80 },
+        unknownAttributes: {},
+    };
+    const endShape = {
+        id: `${endId}_di`,
+        bpmnElement: endId,
+        bounds: { x: 432, y: 100, width: 36, height: 36 },
+        unknownAttributes: {},
+    };
+    const flow1Edge = {
+        id: `${flow1Id}_di`,
+        bpmnElement: flow1Id,
+        waypoints: [
+            { x: 188, y: 118 },
+            { x: 260, y: 118 },
+        ],
+        unknownAttributes: {},
+    };
+    const flow2Edge = {
+        id: `${flow2Id}_di`,
+        bpmnElement: flow2Id,
+        waypoints: [
+            { x: 360, y: 118 },
+            { x: 432, y: 118 },
+        ],
+        unknownAttributes: {},
+    };
+    const diagram = {
+        id: generateId("BPMNDiagram"),
+        plane: {
+            id: generateId("BPMNPlane"),
+            bpmnElement: newProcessId,
+            shapes: [startShape, taskShape, endShape],
+            edges: [flow1Edge, flow2Edge],
+        },
+    };
+    return {
+        id: generateId("Definitions"),
+        targetNamespace: "http://bpmn.io/schema/bpmn",
+        namespaces: {},
+        unknownAttributes: {},
+        errors: [],
+        escalations: [],
+        messages: [],
+        collaborations: [],
+        processes: [extractedProcess],
+        diagrams: [diagram],
+    };
+}
+// ---------------------------------------------------------------------------
+// Task reuse analyzer
+// ---------------------------------------------------------------------------
+export function analyzeTasks(p, opts) {
+    const findings = [];
+    const processId = p.id;
+    const serviceTasks = p.flowElements.filter((el) => el.type === "serviceTask");
+    if (serviceTasks.length < 2)
+        return findings;
+    const groups = cluster(serviceTasks, 0.7).filter((g) => g.length >= opts.reuseThreshold);
+    for (const group of groups) {
+        const representative = group[0];
+        if (!representative)
+            continue;
+        const taskType = readZeebeTaskType(representative.extensionElements) ?? "Unknown";
+        const elementIds = group.map((t) => t.id);
+        findings.push({
+            id: "task/reusable-group",
+            category: "task-reuse",
+            severity: "warning",
+            message: `${group.length} service tasks share a similar configuration (taskType="${taskType}") and could be reused via a call activity.`,
+            suggestion: "Extract the repeated service task into a reusable sub-process and replace occurrences with call activities.",
+            processId,
+            elementIds,
+            applyFix: (defs) => {
+                const proc = findProcess(defs, processId);
+                if (!proc)
+                    return { description: "Process not found" };
+                const newProcessId = `Reusable_${taskType}_${generateId("proc")}`;
+                const generated = buildExtractedDefs(representative, newProcessId);
+                // Replace each task in the group with a call activity
+                for (const taskId of elementIds) {
+                    const orig = proc.flowElements.find((e) => e.id === taskId);
+                    if (!orig || orig.type !== "serviceTask")
+                        continue;
+                    const callActivity = {
+                        type: "callActivity",
+                        id: orig.id,
+                        name: orig.name,
+                        incoming: [...orig.incoming],
+                        outgoing: [...orig.outgoing],
+                        extensionElements: [
+                            {
+                                name: "zeebe:calledElement",
+                                attributes: { processId: newProcessId },
+                                children: [],
+                            },
+                        ],
+                        unknownAttributes: {},
+                    };
+                    proc.flowElements = proc.flowElements.map((e) => (e.id === taskId ? callActivity : e));
+                }
+                return {
+                    description: `Extracted ${group.length} service tasks to call activity referencing "${newProcessId}"`,
+                    generated,
+                };
+            },
+        });
+    }
+    return findings;
+}
+//# sourceMappingURL=tasks.js.map

package/dist/bpmn/optimize/types.d.ts

@@ -0,0 +1,44 @@
+import type { BpmnDefinitions } from "../bpmn-model.js";
+export type OptimizationSeverity = "info" | "warning" | "error";
+export type OptimizationCategory = "feel" | "flow" | "naming" | "task-reuse" | "extract";
+export interface ApplyFixResult {
+    description: string;
+    /** New BpmnDefinitions generated by the fix (e.g. extracted reusable sub-process). */
+    generated?: BpmnDefinitions;
+}
+export interface OptimizationFinding {
+    id: string;
+    category: OptimizationCategory;
+    severity: OptimizationSeverity;
+    message: string;
+    suggestion: string;
+    processId: string;
+    elementIds: string[];
+    /** Mutates `defs` in-place. Returns what changed + any generated file. */
+    applyFix?: (defs: BpmnDefinitions) => ApplyFixResult;
+}
+export interface OptimizationReport {
+    findings: OptimizationFinding[];
+    summary: {
+        total: number;
+        byCategory: Record<OptimizationCategory, number>;
+        bySeverity: Record<OptimizationSeverity, number>;
+    };
+}
+export interface OptimizeOptions {
+    feelLengthThreshold?: number;
+    feelNestingThreshold?: number;
+    feelOperatorThreshold?: number;
+    feelVariableThreshold?: number;
+    reuseThreshold?: number;
+    categories?: OptimizationCategory[];
+}
+export interface ResolvedOptions {
+    feelLengthThreshold: number;
+    feelNestingThreshold: number;
+    feelOperatorThreshold: number;
+    feelVariableThreshold: number;
+    reuseThreshold: number;
+    categories: OptimizationCategory[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/bpmn/optimize/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/bpmn/optimize/utils.d.ts

@@ -0,0 +1,23 @@
+import type { XmlElement } from "../../types/xml-element.js";
+import type { BpmnDefinitions, BpmnDiPlane, BpmnElementType, BpmnFlowElement, BpmnProcess, BpmnSequenceFlow } from "../bpmn-model.js";
+import type { ZeebeIoMapping, ZeebeTaskHeaders } from "../zeebe-extensions.js";
+export declare function readZeebeTaskType(ext: XmlElement[]): string | null;
+export declare function readZeebeIoMapping(ext: XmlElement[]): ZeebeIoMapping | null;
+export declare function readZeebeTaskHeaders(ext: XmlElement[]): ZeebeTaskHeaders | null;
+export interface FlowIndex {
+    byId: Map<string, BpmnFlowElement>;
+    bySource: Map<string, BpmnSequenceFlow[]>;
+    byTarget: Map<string, BpmnSequenceFlow[]>;
+}
+export declare function buildFlowIndex(p: BpmnProcess): FlowIndex;
+export declare function reachableFrom(startIds: string[], bySource: Map<string, BpmnSequenceFlow[]>): Set<string>;
+export declare function isGateway(type: BpmnElementType): boolean;
+export declare function isEndEvent(type: BpmnElementType): boolean;
+export declare function isStartEvent(type: BpmnElementType): boolean;
+export declare function insertElement(p: BpmnProcess, el: BpmnFlowElement): void;
+export declare function removeElement(p: BpmnProcess, id: string): void;
+export declare function insertFlow(p: BpmnProcess, flow: BpmnSequenceFlow): void;
+export declare function removeFlow(p: BpmnProcess, id: string): void;
+export declare function findProcess(defs: BpmnDefinitions, processId: string): BpmnProcess | null;
+export declare function findDiPlane(defs: BpmnDefinitions, processId: string): BpmnDiPlane | null;
+//# sourceMappingURL=utils.d.ts.map

package/dist/bpmn/optimize/utils.js

@@ -0,0 +1,129 @@
+// ---------------------------------------------------------------------------
+// Extension readers
+// ---------------------------------------------------------------------------
+export function readZeebeTaskType(ext) {
+    for (const el of ext) {
+        if (el.name === "zeebe:taskDefinition") {
+            return el.attributes.type ?? null;
+        }
+    }
+    return null;
+}
+export function readZeebeIoMapping(ext) {
+    for (const el of ext) {
+        if (el.name === "zeebe:ioMapping") {
+            const inputs = [];
+            const outputs = [];
+            for (const child of el.children) {
+                if (child.name === "zeebe:input") {
+                    inputs.push({
+                        source: child.attributes.source ?? "",
+                        target: child.attributes.target ?? "",
+                    });
+                }
+                else if (child.name === "zeebe:output") {
+                    outputs.push({
+                        source: child.attributes.source ?? "",
+                        target: child.attributes.target ?? "",
+                    });
+                }
+            }
+            return { inputs, outputs };
+        }
+    }
+    return null;
+}
+export function readZeebeTaskHeaders(ext) {
+    for (const el of ext) {
+        if (el.name === "zeebe:taskHeaders") {
+            const headers = [];
+            for (const child of el.children) {
+                if (child.name === "zeebe:header") {
+                    headers.push({
+                        key: child.attributes.key ?? "",
+                        value: child.attributes.value ?? "",
+                    });
+                }
+            }
+            return { headers };
+        }
+    }
+    return null;
+}
+export function buildFlowIndex(p) {
+    const byId = new Map();
+    const bySource = new Map();
+    const byTarget = new Map();
+    for (const el of p.flowElements) {
+        byId.set(el.id, el);
+    }
+    for (const flow of p.sequenceFlows) {
+        const srcList = bySource.get(flow.sourceRef) ?? [];
+        srcList.push(flow);
+        bySource.set(flow.sourceRef, srcList);
+        const tgtList = byTarget.get(flow.targetRef) ?? [];
+        tgtList.push(flow);
+        byTarget.set(flow.targetRef, tgtList);
+    }
+    return { byId, bySource, byTarget };
+}
+export function reachableFrom(startIds, bySource) {
+    const visited = new Set(startIds);
+    const queue = [...startIds];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === undefined)
+            break;
+        const outflows = bySource.get(current) ?? [];
+        for (const flow of outflows) {
+            if (!visited.has(flow.targetRef)) {
+                visited.add(flow.targetRef);
+                queue.push(flow.targetRef);
+            }
+        }
+    }
+    return visited;
+}
+export function isGateway(type) {
+    return (type === "exclusiveGateway" ||
+        type === "inclusiveGateway" ||
+        type === "complexGateway" ||
+        type === "parallelGateway" ||
+        type === "eventBasedGateway");
+}
+export function isEndEvent(type) {
+    return type === "endEvent";
+}
+export function isStartEvent(type) {
+    return type === "startEvent";
+}
+// ---------------------------------------------------------------------------
+// Mutation helpers
+// ---------------------------------------------------------------------------
+export function insertElement(p, el) {
+    p.flowElements.push(el);
+}
+export function removeElement(p, id) {
+    p.flowElements = p.flowElements.filter((e) => e.id !== id);
+}
+export function insertFlow(p, flow) {
+    p.sequenceFlows.push(flow);
+}
+export function removeFlow(p, id) {
+    p.sequenceFlows = p.sequenceFlows.filter((f) => f.id !== id);
+}
+export function findProcess(defs, processId) {
+    for (const p of defs.processes) {
+        if (p.id === processId)
+            return p;
+    }
+    return null;
+}
+export function findDiPlane(defs, processId) {
+    for (const diagram of defs.diagrams) {
+        if (diagram.plane.bpmnElement === processId)
+            return diagram.plane;
+    }
+    return null;
+}
+//# sourceMappingURL=utils.js.map

package/dist/bpmn/rest-connector.d.ts

@@ -0,0 +1,48 @@
+import type { ZeebeIoMappingEntry, ZeebeTaskHeaderEntry } from "./zeebe-extensions.js";
+/** HTTP methods supported by the Camunda REST connector. */
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+/** Authentication configuration for the REST connector. */
+export type RestAuthentication = {
+    type: "noAuth";
+} | {
+    type: "bearer";
+    token: string;
+};
+/** Configuration for the REST connector convenience builder. */
+export interface RestConnectorConfig {
+    /** Display name for the task. */
+    name?: string;
+    /** HTTP method (GET, POST, PUT, PATCH, DELETE). */
+    method: HttpMethod;
+    /** Target URL — can be a literal string or a FEEL expression (prefix with `=`). */
+    url: string;
+    /** Authentication configuration. Defaults to `{ type: "noAuth" }`. */
+    authentication?: RestAuthentication;
+    /** HTTP headers as key-value pairs or a FEEL expression string. */
+    headers?: Record<string, string> | string;
+    /** Query parameters as a FEEL expression string or key-value pairs. */
+    queryParameters?: Record<string, string> | string;
+    /** Request body — a FEEL expression string or literal value. */
+    body?: string;
+    /** Connection timeout in seconds. Defaults to 20. */
+    connectionTimeoutInSeconds?: number;
+    /** Read timeout in seconds. Defaults to 20. */
+    readTimeoutInSeconds?: number;
+    /** Number of retries on failure. Defaults to "3". */
+    retries?: string;
+    /** Variable name to store the full response. */
+    resultVariable?: string;
+    /** FEEL expression to extract values from the response. */
+    resultExpression?: string;
+    /** Retry backoff duration (ISO 8601 duration, e.g. "PT0S"). */
+    retryBackoff?: string;
+}
+/** Convert a REST connector config into Zeebe IO mapping inputs. */
+export declare function restConnectorToIoMappingInputs(config: RestConnectorConfig): ZeebeIoMappingEntry[];
+/** Get the Zeebe task definition type for REST connectors. */
+export declare function restConnectorTaskType(): string;
+/** Get the default retries value for REST connectors. */
+export declare function restConnectorRetries(config: RestConnectorConfig): string;
+/** Convert a REST connector config into Zeebe task header entries. */
+export declare function restConnectorToTaskHeaders(config: RestConnectorConfig): ZeebeTaskHeaderEntry[];
+//# sourceMappingURL=rest-connector.d.ts.map