@bpmnkit/connectors 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 urbanisierung
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+<div align="center">
+  <a href="https://bpmnkit.com"><img src="https://bpmnkit.com/favicon.svg" width="72" height="72" alt="BPMN Kit logo"></a>
+  <h1>@bpmnkit/connectors</h1>
+  <p>Camunda 8 out-of-the-box connector catalog and deterministic element-template application for @bpmnkit/core</p>
+
+  [![npm](https://img.shields.io/npm/v/@bpmnkit/connectors?style=flat-square&color=6244d7)](https://www.npmjs.com/package/@bpmnkit/connectors)
+  [![license](https://img.shields.io/npm/l/@bpmnkit/connectors?style=flat-square)](https://github.com/bpmnkit/monorepo/blob/main/LICENSE)
+  [![typescript](https://img.shields.io/badge/TypeScript-strict-6244d7?style=flat-square&logo=typescript&logoColor=white)](https://github.com/bpmnkit/monorepo)
+  [![ai-assisted](https://img.shields.io/badge/AI--assisted-claude-8b5cf6?style=flat-square)](https://github.com/bpmnkit/monorepo)
+  [![experimental](https://img.shields.io/badge/status-experimental-f59e0b?style=flat-square)](https://github.com/bpmnkit/monorepo)
+
+  [Website](https://bpmnkit.com) · [Documentation](https://bpmnkit.com/docs) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/packages/connectors/CHANGELOG.md)
+</div>
+
+---
+
+## Overview
+
+`@bpmnkit/connectors` bundles the 116+ Camunda 8 out-of-the-box connector element templates (Slack, SendGrid, HTTP, Kafka, AWS, the agentic-AI family, and more) and applies them to `@bpmnkit/core` builder options deterministically — every binding kind (`zeebe:input`, `zeebe:output`, `zeebe:taskHeader`, `zeebe:taskDefinition`, `zeebe:property`, `zeebe:adHoc`), dropdown-gated conditions, required-field validation, and FEEL parse-checking on FEEL-tagged values.
+
+## Features
+
+- **Full connector catalog** — search and inspect all bundled Camunda 8 OOTB templates
+- **Complete binding resolution** — including `zeebe:property` and `zeebe:output`, which naive appliers drop
+- **Required-field and FEEL validation** — problems are reported, never silently swallowed
+- **Works with any template** — bundled catalog or a custom/generated `ElementTemplate`
+
+## Installation
+
+```sh
+npm install @bpmnkit/connectors
+```
+
+## Quick Start
+
+```typescript
+import { Bpmn } from "@bpmnkit/core"
+import { applyConnectorTemplate, searchConnectors } from "@bpmnkit/connectors"
+
+const [slack] = searchConnectors("slack")
+const result = applyConnectorTemplate(slack.id, {
+  method: "chat.postMessage",
+  token: "{{secrets.SLACK_OAUTH_TOKEN}}",
+  "data.channel": "#ops",
+  "data.text": "=\"Order \" + orderId + \" failed validation\"",
+})
+
+if (result.problems.length > 0) throw new Error(result.problems[0].message)
+
+const defs = Bpmn.createProcess("proc")
+  .startEvent("s")
+  .serviceTask("notify", result.serviceTask!)
+  .endEvent("e")
+  .build()
+```
+
+## Your project's own templates
+
+Drop element templates in `.camunda/element-templates/` and they join the bundled catalogue —
+no project configuration, no registration step. A template nearer the diagram wins over one at
+the project root, which wins over the bundled version of the same id.
+
+```typescript
+import { registerElementTemplates } from "@bpmnkit/connectors"
+import { discoverElementTemplates } from "@bpmnkit/connectors/node"
+
+const { templates, problems } = await discoverElementTemplates({
+  from: "processes/orders/order.bpmn",
+  root: process.cwd(),
+})
+registerElementTemplates(templates)
+// `problems` names every template that was rejected, and why — nothing is dropped silently.
+```
+
+The filesystem half lives behind `@bpmnkit/connectors/node`, so the main entry stays
+importable in a browser: a studio or a viewer takes templates from its host instead.
+
+Validate them in CI with `casen connector validate`.
+
+## API Reference
+
+```typescript
+function listConnectors(): ConnectorSummary[]
+function searchConnectors(query: string): ConnectorSummary[]
+function getTemplate(id: string): ElementTemplate | undefined
+function registerElementTemplates(templates: readonly ElementTemplate[]): void
+function clearRegisteredTemplates(): void
+
+function validateElementTemplate(value: unknown): TemplateValidation
+function readTemplateDocument(value: unknown): TemplateDocumentResult
+
+function applyConnectorTemplate(templateId: string, values?: Record<string, string>): ApplyResult
+function applyElementTemplate(template: ElementTemplate, values?: Record<string, string>): ApplyResult
+
+// @bpmnkit/connectors/node
+function discoverElementTemplates(options: DiscoverOptions): Promise<DiscoveryResult>
+function collectElementTemplates(options: { root: string; configFolder?: string }): Promise<DiscoveryResult>
+
+interface ApplyResult {
+  serviceTask?: ServiceTaskOptions
+  adHocSubProcess?: Partial<AdHocSubProcessOptions>
+  startEvent?: Partial<StartEventOptions>
+  boundaryEvent?: Partial<BoundaryEventOptions>
+  intermediateEvent?: Partial<IntermediateCatchEventOptions>
+  problems: ApplyProblem[]
+}
+```
+
+---
+
+## Related Packages
+
+| Package | Description |
+|---------|-------------|
+| [`@bpmnkit/core`](https://www.npmjs.com/package/@bpmnkit/core) | BPMN/DMN/Form parser, builder, layout engine |
+| [`@bpmnkit/canvas`](https://www.npmjs.com/package/@bpmnkit/canvas) | Zero-dependency SVG BPMN viewer |
+| [`@bpmnkit/editor`](https://www.npmjs.com/package/@bpmnkit/editor) | Full-featured interactive BPMN editor |
+| [`@bpmnkit/engine`](https://www.npmjs.com/package/@bpmnkit/engine) | Lightweight BPMN process execution engine |
+| [`@bpmnkit/feel`](https://www.npmjs.com/package/@bpmnkit/feel) | FEEL expression language parser & evaluator |
+| [`@bpmnkit/plugins`](https://www.npmjs.com/package/@bpmnkit/plugins) | 22 composable canvas plugins |
+| [`@bpmnkit/api`](https://www.npmjs.com/package/@bpmnkit/api) | Camunda 8 REST API TypeScript client |
+| [`@bpmnkit/ascii`](https://www.npmjs.com/package/@bpmnkit/ascii) | Render BPMN diagrams as Unicode ASCII art |
+| [`@bpmnkit/docspack`](https://www.npmjs.com/package/@bpmnkit/docspack) | BPMN Kit docs as an offline docspack package for AI agents |
+| [`@bpmnkit/ui`](https://www.npmjs.com/package/@bpmnkit/ui) | Shared design tokens and UI components |
+| [`@bpmnkit/profiles`](https://www.npmjs.com/package/@bpmnkit/profiles) | Shared auth, profile storage, and client factories for CLI & proxy |
+| [`@bpmnkit/operate`](https://www.npmjs.com/package/@bpmnkit/operate) | Monitoring & operations frontend for Camunda clusters |
+| [`@bpmnkit/connector-gen`](https://www.npmjs.com/package/@bpmnkit/connector-gen) | Generate connector templates from OpenAPI specs |
+| [`@bpmnkit/cli`](https://www.npmjs.com/package/@bpmnkit/cli) | Camunda 8 command-line interface (casen) |
+| [`@bpmnkit/proxy`](https://www.npmjs.com/package/@bpmnkit/proxy) | Local AI bridge and Camunda API proxy server |
+| [`@bpmnkit/patterns`](https://www.npmjs.com/package/@bpmnkit/patterns) | Domain process patterns for BPMNKit AIKit |
+| [`@bpmnkit/reebe-wasm`](https://www.npmjs.com/package/@bpmnkit/reebe-wasm) | WebAssembly BPMN engine for browser simulation |
+| [`@bpmnkit/worker-client`](https://www.npmjs.com/package/@bpmnkit/worker-client) | Thin Zeebe REST client for standalone workers |
+| [`@bpmnkit/cli-sdk`](https://www.npmjs.com/package/@bpmnkit/cli-sdk) | Plugin authoring SDK for the casen CLI |
+| [`@bpmnkit/create-casen-plugin`](https://www.npmjs.com/package/@bpmnkit/create-casen-plugin) | Scaffold a new casen CLI plugin in seconds |
+| [`@bpmnkit/casen-report`](https://www.npmjs.com/package/@bpmnkit/casen-report) | HTML reports from Camunda 8 incident and SLA data |
+| [`@bpmnkit/casen-worker-http`](https://www.npmjs.com/package/@bpmnkit/casen-worker-http) | Example HTTP worker plugin — completes jobs with live JSONPlaceholder API data |
+| [`@bpmnkit/casen-worker-ai`](https://www.npmjs.com/package/@bpmnkit/casen-worker-ai) | AI task worker — classify, summarize, extract, and decide using Claude |
+
+## License
+
+[MIT](https://github.com/bpmnkit/monorepo/blob/main/LICENSE) © BPMN Kit — made by [u11g](https://u11g.com)
+
+<div align="center">
+  <a href="https://bpmnkit.com"><img src="https://bpmnkit.com/favicon.svg" width="32" height="32" alt="BPMN Kit"></a>
+</div>

package/dist/apply.d.ts

@@ -0,0 +1,67 @@
+import type { AdHocSubProcessOptions, BoundaryEventOptions, IntermediateCatchEventOptions, ServiceTaskOptions, StartEventOptions } from "@bpmnkit/core";
+import type { ElementTemplate } from "./template-types.js";
+export interface ApplyProblem {
+    /** The property key this problem is about, if any. */
+    key?: string;
+    message: string;
+    /**
+     * What kind of problem this is — distinguishes a genuinely unmet required
+     * field ("missing-required") from an unrecognized values key
+     * ("unknown-key"), a FEEL syntax error ("invalid-feel"), or a template
+     * with no resolvable task type ("no-task-type"). Callers that specifically
+     * want "what's still required" (e.g. the deploy-lint connector check)
+     * must filter on `kind === "missing-required"` — an unknown key is not
+     * evidence that some other field is missing.
+     */
+    kind?: "missing-required" | "unknown-key" | "invalid-feel" | "no-task-type";
+}
+/**
+ * The result of applying a connector template — exactly one of `serviceTask`,
+ * `adHocSubProcess`, `startEvent`, `boundaryEvent`, or `intermediateEvent` is
+ * set, matching the template's direction. `problems` is always present and
+ * must be checked: a non-empty array means the template could not be fully
+ * applied (missing required value, unknown value key, or a FEEL parse error).
+ */
+export interface ApplyResult {
+    serviceTask?: ServiceTaskOptions;
+    adHocSubProcess?: Partial<AdHocSubProcessOptions>;
+    startEvent?: Partial<StartEventOptions>;
+    boundaryEvent?: Partial<BoundaryEventOptions>;
+    intermediateEvent?: Partial<IntermediateCatchEventOptions>;
+    problems: ApplyProblem[];
+}
+/**
+ * The binding types `applyBinding` below writes.
+ *
+ * Declared beside the switch so the two are edited together: anything the
+ * switch gains belongs here, and `validateElementTemplate` warns about every
+ * binding that is valid but absent from this set — otherwise a template using
+ * one would apply silently and do nothing.
+ */
+export declare const APPLIED_BINDING_TYPES: ReadonlySet<string>;
+/**
+ * Applies a Camunda 8 out-of-the-box connector element template deterministically.
+ *
+ * Unlike a naive apply that only handles `zeebe:input`, this resolves every
+ * binding kind (`zeebe:input`, `zeebe:output`, `zeebe:taskHeader`,
+ * `zeebe:taskDefinition(:type)`, `zeebe:property`, `zeebe:adHoc`), respects
+ * dropdown-gated `condition`s, validates required fields, and parse-validates
+ * any value that looks like a FEEL expression (leading "=").
+ *
+ * `values` keys match `ConnectorSummary.requiredInputs[].key` /
+ * `optionalInputs[].key` from `listConnectors()`/`searchConnectors()`.
+ *
+ * Operates on any {@link ElementTemplate} object — not just the bundled OOTB
+ * catalog — so custom/generated templates (e.g. from `@bpmnkit/connector-gen`)
+ * work the same way. Use {@link applyConnectorTemplate} to apply by bundled
+ * template id instead.
+ */
+export declare function applyElementTemplate(template: ElementTemplate, values?: Record<string, string>): ApplyResult;
+/**
+ * Applies a bundled Camunda 8 out-of-the-box connector element template by
+ * id — see {@link applyElementTemplate} for the full binding-resolution
+ * behavior. Returns a single `problems` entry if `templateId` isn't in the
+ * bundled catalog (use `applyElementTemplate` directly for custom templates).
+ */
+export declare function applyConnectorTemplate(templateId: string, values?: Record<string, string>): ApplyResult;
+//# sourceMappingURL=apply.d.ts.map

package/dist/apply.js

@@ -0,0 +1,243 @@
+import { parseExpression } from "@bpmnkit/feel";
+import { getTemplate, propertyKey } from "./catalog.js";
+function evalCondition(cond, values) {
+    if ("allMatch" in cond) {
+        return cond.allMatch.every((c) => evalCondition(c, values));
+    }
+    if ("equals" in cond)
+        return values[cond.property] === cond.equals;
+    if ("oneOf" in cond)
+        return cond.oneOf.includes(values[cond.property] ?? "");
+    if ("isActive" in cond)
+        return Boolean(values[cond.property]) === cond.isActive;
+    return true;
+}
+function defaultValueOf(prop) {
+    if (prop.value === undefined)
+        return undefined;
+    return String(prop.value);
+}
+/** Resolves every property to its effective string value: user override, else template default. */
+function resolveValues(template, values) {
+    const resolved = {};
+    for (const prop of template.properties) {
+        const key = propertyKey(prop);
+        if (!key)
+            continue;
+        const value = values[key] ?? defaultValueOf(prop);
+        if (value !== undefined)
+            resolved[key] = value;
+    }
+    return resolved;
+}
+/**
+ * The binding types `applyBinding` below writes.
+ *
+ * Declared beside the switch so the two are edited together: anything the
+ * switch gains belongs here, and `validateElementTemplate` warns about every
+ * binding that is valid but absent from this set — otherwise a template using
+ * one would apply silently and do nothing.
+ */
+export const APPLIED_BINDING_TYPES = new Set([
+    "zeebe:input",
+    "zeebe:output",
+    "zeebe:taskHeader",
+    "zeebe:taskDefinition",
+    "zeebe:taskDefinition:type",
+    "zeebe:property",
+    "zeebe:adHoc",
+    "property",
+]);
+function applyBinding(binding, value, accum) {
+    switch (binding.type) {
+        case "zeebe:input":
+            accum.inputs.push({ source: value, target: binding.name });
+            return;
+        case "zeebe:output":
+            // `binding.source` is the template's fixed FEEL read expression (e.g. "=response");
+            // `value` is the user-chosen process-variable name to write it to.
+            accum.outputs.push({ source: binding.source, target: value });
+            return;
+        case "zeebe:taskHeader":
+            accum.taskHeaders[binding.key] = value;
+            return;
+        case "zeebe:taskDefinition":
+            if (binding.property === "type")
+                accum.taskType = value;
+            else
+                accum.retries = value;
+            return;
+        case "zeebe:taskDefinition:type":
+            accum.taskType = value;
+            return;
+        case "zeebe:property":
+            accum.zeebeProperties.push({ name: binding.name, value });
+            return;
+        case "zeebe:adHoc":
+            accum.adHoc[binding.property] = value;
+            return;
+        case "property":
+            // "name" binds to the element's display name — handled by the caller, not here.
+            return;
+        default:
+            return;
+    }
+}
+function directionOf(template) {
+    return template.elementType?.value ?? template.appliesTo[0] ?? "";
+}
+/**
+ * Applies a Camunda 8 out-of-the-box connector element template deterministically.
+ *
+ * Unlike a naive apply that only handles `zeebe:input`, this resolves every
+ * binding kind (`zeebe:input`, `zeebe:output`, `zeebe:taskHeader`,
+ * `zeebe:taskDefinition(:type)`, `zeebe:property`, `zeebe:adHoc`), respects
+ * dropdown-gated `condition`s, validates required fields, and parse-validates
+ * any value that looks like a FEEL expression (leading "=").
+ *
+ * `values` keys match `ConnectorSummary.requiredInputs[].key` /
+ * `optionalInputs[].key` from `listConnectors()`/`searchConnectors()`.
+ *
+ * Operates on any {@link ElementTemplate} object — not just the bundled OOTB
+ * catalog — so custom/generated templates (e.g. from `@bpmnkit/connector-gen`)
+ * work the same way. Use {@link applyConnectorTemplate} to apply by bundled
+ * template id instead.
+ */
+export function applyElementTemplate(template, values = {}) {
+    const resolved = resolveValues(template, values);
+    const problems = [];
+    const knownKeys = new Set(template.properties.map(propertyKey).filter(Boolean));
+    for (const key of Object.keys(values)) {
+        if (key !== "name" && !knownKeys.has(key)) {
+            problems.push({
+                key,
+                kind: "unknown-key",
+                message: `Unknown value key "${key}" for template "${template.id}"`,
+            });
+        }
+    }
+    const accum = {
+        inputs: [],
+        outputs: [],
+        taskHeaders: {},
+        zeebeProperties: [],
+        adHoc: {},
+    };
+    for (const prop of template.properties) {
+        const key = propertyKey(prop);
+        if (prop.condition && !evalCondition(prop.condition, resolved))
+            continue;
+        const value = resolved[key];
+        if (value === undefined || value === "") {
+            if (prop.type !== "Hidden" && prop.constraints?.notEmpty) {
+                problems.push({
+                    key,
+                    kind: "missing-required",
+                    message: `Missing required value for "${prop.label ?? key}" (${key})`,
+                });
+            }
+            continue;
+        }
+        if ((prop.feel === "required" || prop.feel === "optional") && value.startsWith("=")) {
+            const { errors } = parseExpression(value.slice(1));
+            for (const err of errors) {
+                problems.push({
+                    key,
+                    kind: "invalid-feel",
+                    message: `Invalid FEEL expression for "${key}": ${err.message}`,
+                });
+            }
+        }
+        applyBinding(prop.binding, value, accum);
+    }
+    const modelerTemplate = template.id;
+    const modelerTemplateVersion = template.version !== undefined ? String(template.version) : undefined;
+    const modelerTemplateIcon = template.icon?.contents;
+    const name = values.name ?? template.name;
+    const direction = directionOf(template);
+    if (direction === "bpmn:AdHocSubProcess") {
+        return {
+            adHocSubProcess: {
+                name,
+                taskDefinition: accum.taskType
+                    ? { type: accum.taskType, retries: accum.retries }
+                    : undefined,
+                ioMapping: accum.inputs.length || accum.outputs.length
+                    ? { inputs: accum.inputs, outputs: accum.outputs }
+                    : undefined,
+                taskHeaders: Object.keys(accum.taskHeaders).length > 0 ? accum.taskHeaders : undefined,
+                zeebeProperties: accum.zeebeProperties.length > 0 ? accum.zeebeProperties : undefined,
+                outputCollection: accum.adHoc.outputCollection,
+                outputElement: accum.adHoc.outputElement,
+                activeElementsCollection: accum.adHoc.activeElementsCollection,
+                modelerTemplate,
+                modelerTemplateVersion,
+                modelerTemplateIcon,
+            },
+            problems,
+        };
+    }
+    if (direction === "bpmn:StartEvent" ||
+        direction === "bpmn:BoundaryEvent" ||
+        direction === "bpmn:IntermediateCatchEvent" ||
+        direction === "bpmn:ReceiveTask") {
+        if (accum.inputs.length > 0 ||
+            accum.outputs.length > 0 ||
+            Object.keys(accum.taskHeaders).length > 0) {
+            problems.push({
+                message: "Template uses zeebe:input/output/taskHeader bindings on an event-attached element; " +
+                    "applyConnectorTemplate() only maps zeebe:property for start/boundary/intermediate events. " +
+                    "Apply the remaining bindings manually.",
+            });
+        }
+        const partial = {
+            name,
+            zeebeProperties: accum.zeebeProperties.length > 0 ? accum.zeebeProperties : undefined,
+            modelerTemplate,
+            modelerTemplateVersion,
+            modelerTemplateIcon,
+        };
+        if (direction === "bpmn:StartEvent")
+            return { startEvent: partial, problems };
+        if (direction === "bpmn:BoundaryEvent")
+            return { boundaryEvent: partial, problems };
+        return { intermediateEvent: partial, problems };
+    }
+    // Default: outbound service task (bpmn:ServiceTask, bpmn:SendTask, bpmn:EndEvent, bpmn:Task, ...)
+    if (!accum.taskType) {
+        problems.push({
+            kind: "no-task-type",
+            message: `Template "${template.id}" produced no zeebe:taskDefinition type`,
+        });
+    }
+    return {
+        serviceTask: {
+            name,
+            taskType: accum.taskType ?? "",
+            retries: accum.retries,
+            ioMapping: accum.inputs.length || accum.outputs.length
+                ? { inputs: accum.inputs, outputs: accum.outputs }
+                : undefined,
+            taskHeaders: Object.keys(accum.taskHeaders).length > 0 ? accum.taskHeaders : undefined,
+            zeebeProperties: accum.zeebeProperties.length > 0 ? accum.zeebeProperties : undefined,
+            modelerTemplate,
+            modelerTemplateVersion,
+            modelerTemplateIcon,
+        },
+        problems,
+    };
+}
+/**
+ * Applies a bundled Camunda 8 out-of-the-box connector element template by
+ * id — see {@link applyElementTemplate} for the full binding-resolution
+ * behavior. Returns a single `problems` entry if `templateId` isn't in the
+ * bundled catalog (use `applyElementTemplate` directly for custom templates).
+ */
+export function applyConnectorTemplate(templateId, values = {}) {
+    const template = getTemplate(templateId);
+    if (!template) {
+        return { problems: [{ message: `Unknown connector template "${templateId}"` }] };
+    }
+    return applyElementTemplate(template, values);
+}
+//# sourceMappingURL=apply.js.map

package/dist/catalog.d.ts

@@ -0,0 +1,76 @@
+import type { ElementTemplate, TemplateCondition, TemplateProperty } from "./template-types.js";
+/** Where in the process a connector template attaches. */
+export type ConnectorDirection = "outbound" | "inbound-start" | "inbound-intermediate" | "inbound-boundary"
+/** The AI Agent Sub-process connector — an ad-hoc sub-process, not a single task. */
+ | "agentic";
+/** One user-configurable (non-Hidden) property on a connector template. */
+export interface ConnectorInputSpec {
+    /** Lookup key — matches the keys `applyConnectorTemplate()` expects in its `values` argument. */
+    key: string;
+    label: string;
+    description?: string;
+    /** True for fields whose label/key suggest a credential (API key, token, password, secret). */
+    isSecret: boolean;
+    /** True if the field's value is interpreted as FEEL (a leading "=" makes it an expression). */
+    isFeel: boolean;
+    default?: string | number | boolean;
+    choices?: Array<{
+        name: string;
+        value: string;
+    }>;
+    /** This field only applies (and is only required) when this condition holds against other values. */
+    condition?: TemplateCondition;
+}
+/** A connector template reduced to what a skill or LLM needs to select and configure it. */
+export interface ConnectorSummary {
+    id: string;
+    name: string;
+    description?: string;
+    /** Zeebe job type this template sets, e.g. "io.camunda:slack:1". Absent for some inbound templates. */
+    taskType?: string;
+    appliesTo: string[];
+    direction: ConnectorDirection;
+    keywords: string[];
+    requiredInputs: ConnectorInputSpec[];
+    optionalInputs: ConnectorInputSpec[];
+}
+/** Same key-derivation logic used at apply time — kept in sync with `apply.ts`. */
+export declare function propertyKey(prop: TemplateProperty): string;
+/**
+ * What a template will do, without applying it.
+ *
+ * The catalogue computes this for every listing already; it is exported because
+ * anything offering a template to a person needs to be able to say what it
+ * binds and what it will ask for — a picker that applies on the first click is
+ * asking someone to choose blind.
+ *
+ * @param template - The template to describe.
+ */
+export declare function summarizeTemplate(template: ElementTemplate): ConnectorSummary;
+/**
+ * Adds templates to the catalogue, replacing any bundled template with the same
+ * id.
+ *
+ * The workspace wins deliberately: a project that ships its own version of a
+ * connector means it, and the bundle is the fallback. Registering the same id
+ * twice keeps the later one, so a nearer directory can override a further one.
+ *
+ * @param templates - Validated templates. Nothing is checked here; run
+ *   `validateElementTemplate` (or `readTemplateDocument`) at the boundary where
+ *   the JSON was read, so a bad file is reported against its own path.
+ */
+export declare function registerElementTemplates(templates: readonly ElementTemplate[]): void;
+/** Drops every registered template, leaving only the bundled catalogue. */
+export declare function clearRegisteredTemplates(): void;
+/** Every connector template — bundled and registered — as a compact summary. */
+export declare function listConnectors(): ConnectorSummary[];
+/** The full element template for a given template id, registered or bundled. */
+export declare function getTemplate(id: string): ElementTemplate | undefined;
+/**
+ * Keyword-scored search over the bundled connector catalog — mirrors
+ * `@bpmnkit/patterns`' `findPattern()` matching style. Matches against the
+ * template name are weighted highest, then keyword-list matches, then a
+ * general substring match; ties prefer outbound connectors.
+ */
+export declare function searchConnectors(query: string): ConnectorSummary[];
+//# sourceMappingURL=catalog.d.ts.map